From a9a51f2851a105d52325e9258b83806b8de7ffba Mon Sep 17 00:00:00 2001 From: OpenGuidou <73480729+OpenGuidou@users.noreply.github.com> Date: Fri, 13 Oct 2023 17:12:22 +0200 Subject: [PATCH] feat: Support OAuth2 for prometheus and web providers (#3038) Signed-off-by: Guillaume Doussin Signed-off-by: zachaller Co-authored-by: zachaller --- docs/analysis/prometheus.md | 53 +- docs/analysis/web.md | 49 +- .../features/kustomize/rollout_cr_schema.json | 177 ++ go.mod | 2 +- manifests/crds/analysis-run-crd.yaml | 38 + manifests/crds/analysis-template-crd.yaml | 38 + .../crds/cluster-analysis-template-crd.yaml | 38 + manifests/install.yaml | 114 + metricproviders/metricproviders.go | 5 +- metricproviders/prometheus/prometheus.go | 39 +- metricproviders/prometheus/prometheus_test.go | 219 ++ metricproviders/webmetric/webmetric.go | 20 +- metricproviders/webmetric/webmetric_test.go | 207 +- pkg/apis/api-rules/violation_exceptions.list | 4 + pkg/apis/rollouts/v1alpha1/analysis_types.go | 29 +- pkg/apis/rollouts/v1alpha1/generated.pb.go | 1927 ++++++++++------- pkg/apis/rollouts/v1alpha1/generated.proto | 40 +- .../rollouts/v1alpha1/openapi_generated.go | 116 +- .../v1alpha1/zz_generated.deepcopy.go | 59 +- 19 files changed, 2320 insertions(+), 854 deletions(-) diff --git a/docs/analysis/prometheus.md b/docs/analysis/prometheus.md index 786b3d2c6f..b64ed5d06b 100644 --- a/docs/analysis/prometheus.md +++ b/docs/analysis/prometheus.md @@ -39,7 +39,9 @@ you validate your [PromQL expression](https://prometheus.io/docs/prometheus/late See the [Analysis Overview page](../../features/analysis) for more details on the available options. -## Utilizing Amazon Managed Prometheus +## Authorization + +### Utilizing Amazon Managed Prometheus Amazon Managed Prometheus can be used as the prometheus data source for analysis. In order to do this the namespace where your analysis is running will have to have the appropriate [IRSA attached](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-ingest-metrics-new-Prometheus.html#AMP-onboard-new-Prometheus-IRSA) to allow for prometheus queries. Once you ensure the proper permissions are in place to access AMP, you can use an AMP workspace url in your ```provider``` block and add a SigV4 config for Sigv4 signing: @@ -61,6 +63,55 @@ provider: roleArn: $ROLEARN ``` +### With OAuth2 + +You can setup an [OAuth2 client credential](https://datatracker.ietf.org/doc/html/rfc6749#section-4.4) flow using the following values: + +```yaml +apiVersion: argoproj.io/v1alpha1 +kind: AnalysisTemplate +metadata: + name: success-rate +spec: + args: + - name: service-name + # from secret + - name: oauthSecret # This is the OAuth2 shared secret + valueFrom: + secretKeyRef: + name: oauth-secret + key: secret + metrics: + - name: success-rate + interval: 5m + # NOTE: prometheus queries return results in the form of a vector. + # So it is common to access the index 0 of the returned array to obtain the value + successCondition: result[0] >= 0.95 + failureLimit: 3 + provider: + prometheus: + address: http://prometheus.example.com:9090 + # timeout is expressed in seconds + timeout: 40 + authentication: + oauth2: + tokenUrl: https://my-oauth2-provider/token + clientId: my-cliend-id + clientSecret: "{{ args.oauthSecret }}" + scopes: [ + "my-oauth2-scope" + ] + query: | + sum(irate( + istio_requests_total{reporter="source",destination_service=~"{{args.service-name}}",response_code!~"5.*"}[5m] + )) / + sum(irate( + istio_requests_total{reporter="source",destination_service=~"{{args.service-name}}"}[5m] + )) +``` + +The AnalysisRun will first get an access token using that information, and provide it as an `Authorization: Bearer` header for the metric provider call. + ## Additional Metadata Any additional metadata from the Prometheus controller, like the resolved queries after substituting the template's diff --git a/docs/analysis/web.md b/docs/analysis/web.md index db501d0ead..d6ba5abf35 100644 --- a/docs/analysis/web.md +++ b/docs/analysis/web.md @@ -49,7 +49,7 @@ NOTE: if the result is a string, two convenience functions `asInt` and `asFloat` to convert a result value to a numeric type so that mathematical comparison operators can be used (e.g. >, <, >=, <=). -### Optional web methods +## Optional web methods It is possible to use a POST or PUT requests, by specifying the `method` and either `body` or `jsonBody` fields ```yaml @@ -96,7 +96,7 @@ It is possible to use a POST or PUT requests, by specifying the `method` and eit jsonPath: "{$.data.ok}" ``` -### Skip TLS verification +## Skip TLS verification You can skip the TLS verification of the web host provided by setting the options `insecure: true`. @@ -112,4 +112,47 @@ You can skip the TLS verification of the web host provided by setting the option - key: Authorization value: "Bearer {{ args.api-token }}" jsonPath: "{$.data}" -``` \ No newline at end of file +``` +## Authorization + +### With OAuth2 + +You can setup an [OAuth2 client credential](https://datatracker.ietf.org/doc/html/rfc6749#section-4.4) flow using the following values: + +```yaml +apiVersion: argoproj.io/v1alpha1 +kind: AnalysisTemplate +metadata: + name: success-rate +spec: + args: + - name: service-name + # from secret + - name: oauthSecret # This is the OAuth2 shared secret + valueFrom: + secretKeyRef: + name: oauth-secret + key: secret + metrics: + - name: webmetric + successCondition: result == true + provider: + web: + url: "http://my-server.com/api/v1/measurement?service={{ args.service-name }}" + timeoutSeconds: 20 # defaults to 10 seconds + authentication: + oauth2: + tokenUrl: https://my-oauth2-provider/token + clientId: my-cliend-id + clientSecret: "{{ args.oauthSecret }}" + scopes: [ + "my-oauth2-scope" + ] + headers: + - key: Content-Type # if body is a json, it is recommended to set the Content-Type + value: "application/json" + jsonPath: "{$.data.ok}" +``` + +In that case, no need to provide specifically the `Authentication` header. +The AnalysisRun will first get an access token using that information, and provide it as an `Authorization: Bearer` header for the metric provider call. diff --git a/docs/features/kustomize/rollout_cr_schema.json b/docs/features/kustomize/rollout_cr_schema.json index 6d8420e916..8ba598cc82 100644 --- a/docs/features/kustomize/rollout_cr_schema.json +++ b/docs/features/kustomize/rollout_cr_schema.json @@ -4293,6 +4293,26 @@ }, "authentication": { "properties": { + "oauth2": { + "properties": { + "clientId": { + "type": "string" + }, + "clientSecret": { + "type": "string" + }, + "scopes": { + "items": { + "type": "string" + }, + "type": "array" + }, + "tokenUrl": { + "type": "string" + } + }, + "type": "object" + }, "sigv4": { "properties": { "profile": { @@ -4368,6 +4388,45 @@ }, "web": { "properties": { + "authentication": { + "properties": { + "oauth2": { + "properties": { + "clientId": { + "type": "string" + }, + "clientSecret": { + "type": "string" + }, + "scopes": { + "items": { + "type": "string" + }, + "type": "array" + }, + "tokenUrl": { + "type": "string" + } + }, + "type": "object" + }, + "sigv4": { + "properties": { + "profile": { + "type": "string" + }, + "region": { + "type": "string" + }, + "roleArn": { + "type": "string" + } + }, + "type": "object" + } + }, + "type": "object" + }, "body": { "type": "string" }, @@ -8740,6 +8799,26 @@ }, "authentication": { "properties": { + "oauth2": { + "properties": { + "clientId": { + "type": "string" + }, + "clientSecret": { + "type": "string" + }, + "scopes": { + "items": { + "type": "string" + }, + "type": "array" + }, + "tokenUrl": { + "type": "string" + } + }, + "type": "object" + }, "sigv4": { "properties": { "profile": { @@ -8815,6 +8894,45 @@ }, "web": { "properties": { + "authentication": { + "properties": { + "oauth2": { + "properties": { + "clientId": { + "type": "string" + }, + "clientSecret": { + "type": "string" + }, + "scopes": { + "items": { + "type": "string" + }, + "type": "array" + }, + "tokenUrl": { + "type": "string" + } + }, + "type": "object" + }, + "sigv4": { + "properties": { + "profile": { + "type": "string" + }, + "region": { + "type": "string" + }, + "roleArn": { + "type": "string" + } + }, + "type": "object" + } + }, + "type": "object" + }, "body": { "type": "string" }, @@ -13187,6 +13305,26 @@ }, "authentication": { "properties": { + "oauth2": { + "properties": { + "clientId": { + "type": "string" + }, + "clientSecret": { + "type": "string" + }, + "scopes": { + "items": { + "type": "string" + }, + "type": "array" + }, + "tokenUrl": { + "type": "string" + } + }, + "type": "object" + }, "sigv4": { "properties": { "profile": { @@ -13262,6 +13400,45 @@ }, "web": { "properties": { + "authentication": { + "properties": { + "oauth2": { + "properties": { + "clientId": { + "type": "string" + }, + "clientSecret": { + "type": "string" + }, + "scopes": { + "items": { + "type": "string" + }, + "type": "array" + }, + "tokenUrl": { + "type": "string" + } + }, + "type": "object" + }, + "sigv4": { + "properties": { + "profile": { + "type": "string" + }, + "region": { + "type": "string" + }, + "roleArn": { + "type": "string" + } + }, + "type": "object" + } + }, + "type": "object" + }, "body": { "type": "string" }, diff --git a/go.mod b/go.mod index 4edaa2530a..5340295b69 100644 --- a/go.mod +++ b/go.mod @@ -36,6 +36,7 @@ require ( github.com/stretchr/testify v1.8.4 github.com/tj/assert v0.0.3 github.com/valyala/fasttemplate v1.2.2 + golang.org/x/oauth2 v0.10.0 google.golang.org/genproto/googleapis/api v0.0.0-20230711160842-782d3b101e98 google.golang.org/grpc v1.58.3 google.golang.org/protobuf v1.31.0 @@ -179,7 +180,6 @@ require ( golang.org/x/crypto v0.11.0 // indirect golang.org/x/mod v0.8.0 // indirect golang.org/x/net v0.12.0 // indirect - golang.org/x/oauth2 v0.10.0 // indirect golang.org/x/sys v0.10.0 // indirect golang.org/x/term v0.10.0 // indirect golang.org/x/text v0.11.0 // indirect diff --git a/manifests/crds/analysis-run-crd.yaml b/manifests/crds/analysis-run-crd.yaml index 112b5e7287..9bf67d49b8 100644 --- a/manifests/crds/analysis-run-crd.yaml +++ b/manifests/crds/analysis-run-crd.yaml @@ -2799,6 +2799,19 @@ spec: type: string authentication: properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object sigv4: properties: profile: @@ -2847,6 +2860,31 @@ spec: type: object web: properties: + authentication: + properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object + sigv4: + properties: + profile: + type: string + region: + type: string + roleArn: + type: string + type: object + type: object body: type: string headers: diff --git a/manifests/crds/analysis-template-crd.yaml b/manifests/crds/analysis-template-crd.yaml index 8f76efa195..591847282f 100644 --- a/manifests/crds/analysis-template-crd.yaml +++ b/manifests/crds/analysis-template-crd.yaml @@ -2795,6 +2795,19 @@ spec: type: string authentication: properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object sigv4: properties: profile: @@ -2843,6 +2856,31 @@ spec: type: object web: properties: + authentication: + properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object + sigv4: + properties: + profile: + type: string + region: + type: string + roleArn: + type: string + type: object + type: object body: type: string headers: diff --git a/manifests/crds/cluster-analysis-template-crd.yaml b/manifests/crds/cluster-analysis-template-crd.yaml index 4e5187d8df..e02cf80946 100644 --- a/manifests/crds/cluster-analysis-template-crd.yaml +++ b/manifests/crds/cluster-analysis-template-crd.yaml @@ -2795,6 +2795,19 @@ spec: type: string authentication: properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object sigv4: properties: profile: @@ -2843,6 +2856,31 @@ spec: type: object web: properties: + authentication: + properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object + sigv4: + properties: + profile: + type: string + region: + type: string + roleArn: + type: string + type: object + type: object body: type: string headers: diff --git a/manifests/install.yaml b/manifests/install.yaml index ddcd3e3d66..54c65cc56c 100755 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -2800,6 +2800,19 @@ spec: type: string authentication: properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object sigv4: properties: profile: @@ -2848,6 +2861,31 @@ spec: type: object web: properties: + authentication: + properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object + sigv4: + properties: + profile: + type: string + region: + type: string + roleArn: + type: string + type: object + type: object body: type: string headers: @@ -5808,6 +5846,19 @@ spec: type: string authentication: properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object sigv4: properties: profile: @@ -5856,6 +5907,31 @@ spec: type: object web: properties: + authentication: + properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object + sigv4: + properties: + profile: + type: string + region: + type: string + roleArn: + type: string + type: object + type: object body: type: string headers: @@ -8702,6 +8778,19 @@ spec: type: string authentication: properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object sigv4: properties: profile: @@ -8750,6 +8839,31 @@ spec: type: object web: properties: + authentication: + properties: + oauth2: + properties: + clientId: + type: string + clientSecret: + type: string + scopes: + items: + type: string + type: array + tokenUrl: + type: string + type: object + sigv4: + properties: + profile: + type: string + region: + type: string + roleArn: + type: string + type: object + type: object body: type: string headers: diff --git a/metricproviders/metricproviders.go b/metricproviders/metricproviders.go index f73ff15e88..1be0042c23 100644 --- a/metricproviders/metricproviders.go +++ b/metricproviders/metricproviders.go @@ -48,7 +48,10 @@ func (f *ProviderFactory) NewProvider(logCtx log.Entry, metric v1alpha1.Metric) c := kayenta.NewHttpClient() return kayenta.NewKayentaProvider(logCtx, c), nil case webmetric.ProviderType: - c := webmetric.NewWebMetricHttpClient(metric) + c, err := webmetric.NewWebMetricHttpClient(metric) + if err != nil { + return nil, err + } p, err := webmetric.NewWebMetricJsonParser(metric) if err != nil { return nil, err diff --git a/metricproviders/prometheus/prometheus.go b/metricproviders/prometheus/prometheus.go index 6d1d521fb0..7473693525 100644 --- a/metricproviders/prometheus/prometheus.go +++ b/metricproviders/prometheus/prometheus.go @@ -17,6 +17,8 @@ import ( "github.com/prometheus/common/model" "github.com/prometheus/common/sigv4" log "github.com/sirupsen/logrus" + "golang.org/x/oauth2" + "golang.org/x/oauth2/clientcredentials" "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" "github.com/argoproj/argo-rollouts/utils/evaluate" @@ -164,6 +166,7 @@ func NewPrometheusProvider(api v1.API, logCtx log.Entry, metric v1alpha1.Metric) // NewPrometheusAPI generates a prometheus API from the metric configuration func NewPrometheusAPI(metric v1alpha1.Metric) (v1.API, error) { envValuesByKey := make(map[string]string) + if value, ok := os.LookupEnv(fmt.Sprintf("%s", EnvVarArgoRolloutsPrometheusAddress)); ok { envValuesByKey[EnvVarArgoRolloutsPrometheusAddress] = value log.Debugf("ARGO_ROLLOUTS_PROMETHEUS_ADDRESS: %v", envValuesByKey[EnvVarArgoRolloutsPrometheusAddress]) @@ -203,25 +206,42 @@ func NewPrometheusAPI(metric v1alpha1.Metric) (v1.API, error) { } } - prometheusApiConfig := api.Config{ - Address: metric.Provider.Prometheus.Address, - RoundTripper: roundTripper, - } - //Check if using Amazon Managed Prometheus if true build sigv4 client - if strings.Contains(metric.Provider.Prometheus.Address, "aps-workspaces") { + if strings.Contains(metric.Provider.Prometheus.Address, "aps-workspaces") && (v1alpha1.Sigv4Config{}) != metric.Provider.Prometheus.Authentication.Sigv4 { cfg := sigv4.SigV4Config{ Region: metric.Provider.Prometheus.Authentication.Sigv4.Region, Profile: metric.Provider.Prometheus.Authentication.Sigv4.Profile, RoleARN: metric.Provider.Prometheus.Authentication.Sigv4.RoleARN, } - var next http.RoundTripper - sigv4RoundTripper, err := sigv4.NewSigV4RoundTripper(&cfg, next) + sigv4RoundTripper, err := sigv4.NewSigV4RoundTripper(&cfg, roundTripper) if err != nil { log.Errorf("Error creating SigV4 RoundTripper: %v", err) return nil, err } - prometheusApiConfig.RoundTripper = sigv4RoundTripper + roundTripper = sigv4RoundTripper + } + + httpClient := &http.Client{ + Transport: roundTripper, + } + + if metric.Provider.Prometheus.Authentication.OAuth2.TokenURL != "" { + if metric.Provider.Prometheus.Authentication.OAuth2.ClientID == "" || metric.Provider.Prometheus.Authentication.OAuth2.ClientSecret == "" { + return nil, errors.New("missing mandatory parameter in metric for OAuth2 setup") + } + oauthCfg := &clientcredentials.Config{ + ClientID: metric.Provider.Prometheus.Authentication.OAuth2.ClientID, + ClientSecret: metric.Provider.Prometheus.Authentication.OAuth2.ClientSecret, + TokenURL: metric.Provider.Prometheus.Authentication.OAuth2.TokenURL, + Scopes: metric.Provider.Prometheus.Authentication.OAuth2.Scopes, + } + ctx := context.WithValue(context.Background(), oauth2.HTTPClient, httpClient) + httpClient = oauthCfg.Client(ctx) + } + + prometheusApiConfig := api.Config{ + Address: metric.Provider.Prometheus.Address, + Client: httpClient, } client, err := api.NewClient(prometheusApiConfig) @@ -229,6 +249,7 @@ func NewPrometheusAPI(metric v1alpha1.Metric) (v1.API, error) { log.Errorf("Error in getting prometheus client: %v", err) return nil, err } + return v1.NewAPI(client), nil } diff --git a/metricproviders/prometheus/prometheus_test.go b/metricproviders/prometheus/prometheus_test.go index 8b077930a5..f54d6d6c61 100644 --- a/metricproviders/prometheus/prometheus_test.go +++ b/metricproviders/prometheus/prometheus_test.go @@ -3,7 +3,10 @@ package prometheus import ( "fmt" "math" + "net/http" + "net/http/httptest" "os" + "strings" "testing" "time" @@ -15,6 +18,16 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) +const ( + AccessToken = "MyAccessToken" +) + +type OAuthResponse struct { + TokenType string `json:"token_type,omitempty"` + AccessToken string `json:"access_token,omitempty"` + Expiry string `json:"expires_in,omitempty"` +} + func newScalar(f float64) model.Value { return &model.Scalar{ Value: model.SampleValue(f), @@ -514,3 +527,209 @@ func TestNewPrometheusNegativeTimeout(t *testing.T) { assert.NotNil(t, err) assert.Nil(t, p) } + +func TestRunSuccessfulWithOAuth(t *testing.T) { + e := log.Entry{} + promServer := mockPromServer(AccessToken) + oAuthServer := mockOAuthServer(AccessToken) + defer promServer.Close() + defer oAuthServer.Close() + + metric := v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result[0] == 10", + FailureCondition: "result[0] != 10", + Provider: v1alpha1.MetricProvider{ + Prometheus: &v1alpha1.PrometheusMetric{ + Address: promServer.URL, + Query: "test", + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: oAuthServer.URL + "/ok", + ClientID: "someId", + ClientSecret: "mySecret", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + } + api, err := NewPrometheusAPI(metric) + assert.NoError(t, err) + p, err := NewPrometheusProvider(api, e, metric) + + measurement := p.Run(newAnalysisRun(), metric) + assert.NotNil(t, measurement.StartedAt) + assert.NoError(t, err) + assert.Equal(t, "[10]", measurement.Value) + assert.NotNil(t, measurement.FinishedAt) + assert.Equal(t, v1alpha1.AnalysisPhaseSuccessful, measurement.Phase) +} + +func TestNewPromApiErrorWithIncompleteOAuthParams(t *testing.T) { + + metric := v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result[0] == 10", + FailureCondition: "result[0] != 10", + Provider: v1alpha1.MetricProvider{ + Prometheus: &v1alpha1.PrometheusMetric{ + Address: "http://promurl", + Query: "test", + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: "http://tokenurl", + ClientSecret: "mySecret", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + } + _, err := NewPrometheusAPI(metric) + assert.Error(t, err) + + metric = v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result[0] == 10", + FailureCondition: "result[0] != 10", + Provider: v1alpha1.MetricProvider{ + Prometheus: &v1alpha1.PrometheusMetric{ + Address: "http://promurl", + Query: "test", + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: "http://tokenurl", + ClientID: "someId", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + } + _, err = NewPrometheusAPI(metric) + assert.Error(t, err) + + metric = v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result[0] == 10", + FailureCondition: "result[0] != 10", + Provider: v1alpha1.MetricProvider{ + Prometheus: &v1alpha1.PrometheusMetric{ + Address: "http://promurl", + Query: "test", + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: "http://tokenurl", + ClientID: "someId", + ClientSecret: "mySecret", + }, + }, + }, + }, + } + _, err = NewPrometheusAPI(metric) + // scopes are optional + assert.NoError(t, err) +} + +func TestRunErrorOAuthFailure(t *testing.T) { + e := log.Entry{} + promServer := mockPromServer(AccessToken) + oAuthServer := mockOAuthServer(AccessToken) + defer promServer.Close() + defer oAuthServer.Close() + + metric := v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result[0] == 10", + FailureCondition: "result[0] != 10", + Provider: v1alpha1.MetricProvider{ + Prometheus: &v1alpha1.PrometheusMetric{ + Address: promServer.URL, + Query: "test", + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: oAuthServer.URL + "/ko", + ClientID: "someId", + ClientSecret: "mySecret", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + } + api, err := NewPrometheusAPI(metric) + assert.NoError(t, err) + p, err := NewPrometheusProvider(api, e, metric) + + measurement := p.Run(newAnalysisRun(), metric) + assert.NoError(t, err) + assert.Equal(t, v1alpha1.AnalysisPhaseError, measurement.Phase) +} + +func mockOAuthServer(accessToken string) *httptest.Server { + return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + log.StandardLogger().Infof("Received oauth query") + switch strings.TrimSpace(r.URL.Path) { + case "/ok": + mockOAuthOKResponse(w, r, accessToken) + case "/ko": + mockOAuthKOResponse(w, r) + default: + http.NotFoundHandler().ServeHTTP(w, r) + } + })) +} + +func mockOAuthOKResponse(w http.ResponseWriter, r *http.Request, accessToken string) { + + oAuthResponse := fmt.Sprintf(`{"token_type":"Bearer","expires_in":3599,"access_token":"%s"}`, accessToken) + + sc := http.StatusOK + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(sc) + w.Write([]byte(oAuthResponse)) +} + +func mockOAuthKOResponse(w http.ResponseWriter, r *http.Request) { + sc := http.StatusUnauthorized + w.WriteHeader(sc) +} + +func mockPromServer(expectedAuthorizationHeader string) *httptest.Server { + return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + + log.StandardLogger().Infof("Received prom query") + + authorizationHeader := r.Header.Get("Authorization") + // Reject call if we don't find the expected oauth token + if expectedAuthorizationHeader != "" && ("Bearer "+expectedAuthorizationHeader) != authorizationHeader { + + log.StandardLogger().Infof("Authorization header not as expected, rejecting") + sc := http.StatusUnauthorized + w.WriteHeader(sc) + + } else { + log.StandardLogger().Infof("Authorization header as expected, continuing") + promResponse := `{"data":{"result":[{"metric":{"__name__":"myMetric"},"value":[0, "10"]}],"resultType":"vector"},"status":"success"}` + + sc := http.StatusOK + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(sc) + w.Write([]byte(promResponse)) + } + })) +} diff --git a/metricproviders/webmetric/webmetric.go b/metricproviders/webmetric/webmetric.go index 3ec345b90f..6561e72290 100644 --- a/metricproviders/webmetric/webmetric.go +++ b/metricproviders/webmetric/webmetric.go @@ -2,6 +2,7 @@ package webmetric import ( "bytes" + "context" "crypto/tls" "encoding/json" "errors" @@ -13,6 +14,8 @@ import ( "time" log "github.com/sirupsen/logrus" + "golang.org/x/oauth2" + "golang.org/x/oauth2/clientcredentials" "k8s.io/client-go/util/jsonpath" "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" @@ -173,8 +176,9 @@ func (p *Provider) GarbageCollect(run *v1alpha1.AnalysisRun, metric v1alpha1.Met return nil } -func NewWebMetricHttpClient(metric v1alpha1.Metric) *http.Client { +func NewWebMetricHttpClient(metric v1alpha1.Metric) (*http.Client, error) { var timeout time.Duration + var oauthCfg clientcredentials.Config // Using a default timeout of 10 seconds if metric.Provider.Web.TimeoutSeconds <= 0 { @@ -192,7 +196,19 @@ func NewWebMetricHttpClient(metric v1alpha1.Metric) *http.Client { } c.Transport = tr } - return c + if metric.Provider.Web.Authentication.OAuth2.TokenURL != "" { + if metric.Provider.Web.Authentication.OAuth2.ClientID == "" || metric.Provider.Web.Authentication.OAuth2.ClientSecret == "" { + return nil, errors.New("missing mandatory parameter in metric for OAuth2 setup") + } + oauthCfg = clientcredentials.Config{ + ClientID: metric.Provider.Web.Authentication.OAuth2.ClientID, + ClientSecret: metric.Provider.Web.Authentication.OAuth2.ClientSecret, + TokenURL: metric.Provider.Web.Authentication.OAuth2.TokenURL, + Scopes: metric.Provider.Web.Authentication.OAuth2.Scopes, + } + return oauthCfg.Client(context.WithValue(context.Background(), oauth2.HTTPClient, c)), nil + } + return c, nil } func NewWebMetricJsonParser(metric v1alpha1.Metric) (*jsonpath.JSONPath, error) { diff --git a/metricproviders/webmetric/webmetric_test.go b/metricproviders/webmetric/webmetric_test.go index 5ec0422ce1..1f8556a0eb 100644 --- a/metricproviders/webmetric/webmetric_test.go +++ b/metricproviders/webmetric/webmetric_test.go @@ -3,9 +3,11 @@ package webmetric import ( "bytes" "encoding/json" + "fmt" "io" "net/http" "net/http/httptest" + "strings" "testing" "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1" @@ -13,19 +15,30 @@ import ( "github.com/stretchr/testify/assert" ) +const ( + AccessToken = "MyAccessToken" +) + func TestRunSuite(t *testing.T) { + + // Start OAuth server + oAuthServer := mockOAuthServer(AccessToken) + defer oAuthServer.Close() + // Test Cases var tests = []struct { - webServerStatus int - webServerResponse string - metric v1alpha1.Metric - expectedMethod string - expectedBody string - expectedValue string - expectedPhase v1alpha1.AnalysisPhase - expectedErrorMessage string - expectedJsonBody string + webServerStatus int + webServerResponse string + metric v1alpha1.Metric + expectedMethod string + expectedBody string + expectedValue string + expectedPhase v1alpha1.AnalysisPhase + expectedErrorMessage string + expectedJsonBody string + expectedAuthorizationHeader string }{ + // When_noJSONPathSpecified_And_MatchesConditions_Then_Succeed { webServerStatus: 200, @@ -651,6 +664,63 @@ func TestRunSuite(t *testing.T) { expectedValue: "use either Body or JSONBody; both cannot exists for WebMetric payload", expectedPhase: v1alpha1.AnalysisPhaseError, }, + // When_usingOAuth2_Then_Succeed + { + webServerStatus: 200, + webServerResponse: `{"a": 1, "b": true, "c": [1, 2, 3, 4], "d": null}`, + metric: v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result.a > 0 && result.b && all(result.c, {# < 5}) && result.d == nil", + Provider: v1alpha1.MetricProvider{ + Web: &v1alpha1.WebMetric{ + // URL: server.URL, + Headers: []v1alpha1.WebMetricHeader{{Key: "key", Value: "value"}}, + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: oAuthServer.URL + "/ok", + ClientID: "myClientID", + ClientSecret: "mySecret", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + }, + expectedAuthorizationHeader: AccessToken, + expectedValue: `{"a":1,"b":true,"c":[1,2,3,4],"d":null}`, + expectedPhase: v1alpha1.AnalysisPhaseSuccessful, + }, + // When_RejectedByOAuthServer_Then_Failure + { + webServerResponse: `Missing OAuth2 token`, + metric: v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result.a > 0 && result.b && all(result.c, {# < 5}) && result.d == nil", + Provider: v1alpha1.MetricProvider{ + Web: &v1alpha1.WebMetric{ + // URL: server.URL, + Headers: []v1alpha1.WebMetricHeader{{Key: "key", Value: "value"}}, + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: oAuthServer.URL + "/ko", + ClientID: "myClientID", + ClientSecret: "mySecret", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + }, + expectedAuthorizationHeader: AccessToken, + expectedErrorMessage: `oauth2: cannot fetch token: 401 Unauthorized`, + expectedPhase: v1alpha1.AnalysisPhaseError, + }, } // Run @@ -658,6 +728,18 @@ func TestRunSuite(t *testing.T) { for _, test := range tests { // Server setup with response server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { + + authorizationHeader := req.Header.Get("Authorization") + // Reject call if we don't find the expected oauth token + if test.expectedAuthorizationHeader != "" && ("Bearer "+test.expectedAuthorizationHeader) != authorizationHeader { + + log.StandardLogger().Infof("Authorization header not as expected, rejecting") + sc := http.StatusUnauthorized + rw.WriteHeader(sc) + io.WriteString(rw, test.webServerResponse) + return + } + if test.expectedMethod != "" { assert.Equal(t, test.expectedMethod, req.Method) } @@ -694,7 +776,9 @@ func TestRunSuite(t *testing.T) { jsonparser, err := NewWebMetricJsonParser(test.metric) assert.NoError(t, err) - provider := NewWebMetricProvider(*logCtx, server.Client(), jsonparser) + client, err := NewWebMetricHttpClient(test.metric) + assert.NoError(t, err) + provider := NewWebMetricProvider(*logCtx, client, jsonparser) metricsMetadata := provider.GetMetadata(test.metric) assert.Nil(t, metricsMetadata) @@ -725,6 +809,109 @@ func TestRunSuite(t *testing.T) { } } +func TestNewPromApiErrorWithIncompleteOAuthParams(t *testing.T) { + + // Missing Client Id should fail + metric := v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result.a > 0 && result.b && all(result.c, {# < 5}) && result.d == nil", + Provider: v1alpha1.MetricProvider{ + Web: &v1alpha1.WebMetric{ + // URL: server.URL, + Headers: []v1alpha1.WebMetricHeader{{Key: "key", Value: "value"}}, + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: "http://tokenurl", + ClientSecret: "mySecret", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + } + + _, err := NewWebMetricHttpClient(metric) + assert.Error(t, err) + + // Missing Client Secret should fail + metric = v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result.a > 0 && result.b && all(result.c, {# < 5}) && result.d == nil", + Provider: v1alpha1.MetricProvider{ + Web: &v1alpha1.WebMetric{ + // URL: server.URL, + Headers: []v1alpha1.WebMetricHeader{{Key: "key", Value: "value"}}, + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: "http://tokenurl", + ClientID: "myClientID", + Scopes: []string{ + "myFirstScope", + "mySecondScope", + }, + }, + }, + }, + }, + } + _, err = NewWebMetricHttpClient(metric) + assert.Error(t, err) + + // Missing Scope should succeed + metric = v1alpha1.Metric{ + Name: "foo", + SuccessCondition: "result.a > 0 && result.b && all(result.c, {# < 5}) && result.d == nil", + Provider: v1alpha1.MetricProvider{ + Web: &v1alpha1.WebMetric{ + // URL: server.URL, + Headers: []v1alpha1.WebMetricHeader{{Key: "key", Value: "value"}}, + Authentication: v1alpha1.Authentication{ + OAuth2: v1alpha1.OAuth2Config{ + TokenURL: "http://tokenurl", + ClientID: "myClientID", + ClientSecret: "mySecret", + }, + }, + }, + }, + } + _, err = NewWebMetricHttpClient(metric) + assert.NoError(t, err) + +} + func newAnalysisRun() *v1alpha1.AnalysisRun { return &v1alpha1.AnalysisRun{} } + +func mockOAuthServer(accessToken string) *httptest.Server { + return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + log.StandardLogger().Infof("Received oauth query") + switch strings.TrimSpace(r.URL.Path) { + case "/ok": + mockOAuthOKResponse(w, r, accessToken) + case "/ko": + mockOAuthKOResponse(w, r) + default: + http.NotFoundHandler().ServeHTTP(w, r) + } + })) +} + +func mockOAuthOKResponse(w http.ResponseWriter, r *http.Request, accessToken string) { + + oAuthResponse := fmt.Sprintf(`{"token_type":"Bearer","expires_in":3599,"access_token":"%s"}`, accessToken) + + sc := http.StatusOK + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(sc) + w.Write([]byte(oAuthResponse)) +} + +func mockOAuthKOResponse(w http.ResponseWriter, r *http.Request) { + sc := http.StatusUnauthorized + w.WriteHeader(sc) +} diff --git a/pkg/apis/api-rules/violation_exceptions.list b/pkg/apis/api-rules/violation_exceptions.list index 1d968d19e0..e947b953c9 100644 --- a/pkg/apis/api-rules/violation_exceptions.list +++ b/pkg/apis/api-rules/violation_exceptions.list @@ -29,6 +29,7 @@ API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,KayentaMetric,Scopes API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,MetricResult,Measurements API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,NginxTrafficRouting,StableIngresses +API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,OAuth2Config,Scopes API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,PrometheusMetric,Headers API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,RolloutAnalysis,Args API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,RolloutAnalysis,DryRun @@ -46,7 +47,10 @@ API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,TLSRoute,SNIHosts API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,TrafficWeights,Additional API rule violation: list_type_missing,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,WebMetric,Headers +API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,Authentication,OAuth2 API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,MetricProvider,SkyWalking +API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,OAuth2Config,ClientID +API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,OAuth2Config,TokenURL API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,RolloutStatus,ALBs API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,RolloutStatus,HPAReplicas API rule violation: names_match,github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1,Sigv4Config,RoleARN diff --git a/pkg/apis/rollouts/v1alpha1/analysis_types.go b/pkg/apis/rollouts/v1alpha1/analysis_types.go index d7d1685d04..1988f44169 100644 --- a/pkg/apis/rollouts/v1alpha1/analysis_types.go +++ b/pkg/apis/rollouts/v1alpha1/analysis_types.go @@ -210,9 +210,9 @@ type PrometheusMetric struct { Address string `json:"address,omitempty" protobuf:"bytes,1,opt,name=address"` // Query is a raw prometheus query to perform Query string `json:"query,omitempty" protobuf:"bytes,2,opt,name=query"` - // Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus + // Authentication details // +optional - Authentication PrometheusAuth `json:"authentication,omitempty" protobuf:"bytes,3,opt,name=authentication"` + Authentication Authentication `json:"authentication,omitempty" protobuf:"bytes,3,opt,name=authentication"` // Timeout represents the duration within which a prometheus query should complete. It is expressed in seconds. // +optional Timeout *int64 `json:"timeout,omitempty" protobuf:"bytes,4,opt,name=timeout"` @@ -225,10 +225,26 @@ type PrometheusMetric struct { Headers []WebMetricHeader `json:"headers,omitempty" patchStrategy:"merge" patchMergeKey:"key" protobuf:"bytes,6,opt,name=headers"` } -// PrometheusMetric defines the prometheus query to perform canary analysis -type PrometheusAuth struct { +// Authentication method +type Authentication struct { + // Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus + // +optional + Sigv4 Sigv4Config `json:"sigv4,omitempty" protobuf:"bytes,1,opt,name=sigv4"` + // OAuth2 config // +optional - Sigv4 Sigv4Config `json:"sigv4,omitempty" protobuf:"bytes,3,opt,name=sigv4"` + OAuth2 OAuth2Config `json:"oauth2,omitempty" protobuf:"bytes,2,opt,name=oauth2"` +} + +type OAuth2Config struct { + // OAuth2 provider token URL + TokenURL string `json:"tokenUrl,omitempty" protobuf:"bytes,1,name=tokenUrl"` + // OAuth2 client ID + ClientID string `json:"clientId,omitempty" protobuf:"bytes,2,name=clientId"` + // OAuth2 client secret + ClientSecret string `json:"clientSecret,omitempty" protobuf:"bytes,3,name=clientSecret"` + // OAuth2 scopes + // +optional + Scopes []string `json:"scopes,omitempty" protobuf:"bytes,4,opt,name=scopes"` } type Sigv4Config struct { @@ -532,6 +548,9 @@ type WebMetric struct { // +kubebuilder:validation:Type=object // JSONBody is the body of the web metric in a json format (method must be POST/PUT) JSONBody json.RawMessage `json:"jsonBody,omitempty" protobuf:"bytes,8,opt,name=jsonBody,casttype=encoding/json.RawMessage"` + // Authentication details + // +optional + Authentication Authentication `json:"authentication,omitempty" protobuf:"bytes,9,opt,name=authentication"` } // WebMetricMethod is the available HTTP methods diff --git a/pkg/apis/rollouts/v1alpha1/generated.pb.go b/pkg/apis/rollouts/v1alpha1/generated.pb.go index 7a0c3ccf23..bfefbed404 100644 --- a/pkg/apis/rollouts/v1alpha1/generated.pb.go +++ b/pkg/apis/rollouts/v1alpha1/generated.pb.go @@ -665,10 +665,38 @@ func (m *ArgumentValueFrom) XXX_DiscardUnknown() { var xxx_messageInfo_ArgumentValueFrom proto.InternalMessageInfo +func (m *Authentication) Reset() { *m = Authentication{} } +func (*Authentication) ProtoMessage() {} +func (*Authentication) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{22} +} +func (m *Authentication) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Authentication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *Authentication) XXX_Merge(src proto.Message) { + xxx_messageInfo_Authentication.Merge(m, src) +} +func (m *Authentication) XXX_Size() int { + return m.Size() +} +func (m *Authentication) XXX_DiscardUnknown() { + xxx_messageInfo_Authentication.DiscardUnknown(m) +} + +var xxx_messageInfo_Authentication proto.InternalMessageInfo + func (m *AwsResourceRef) Reset() { *m = AwsResourceRef{} } func (*AwsResourceRef) ProtoMessage() {} func (*AwsResourceRef) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{22} + return fileDescriptor_e0e705f843545fab, []int{23} } func (m *AwsResourceRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -696,7 +724,7 @@ var xxx_messageInfo_AwsResourceRef proto.InternalMessageInfo func (m *BlueGreenStatus) Reset() { *m = BlueGreenStatus{} } func (*BlueGreenStatus) ProtoMessage() {} func (*BlueGreenStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{23} + return fileDescriptor_e0e705f843545fab, []int{24} } func (m *BlueGreenStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -724,7 +752,7 @@ var xxx_messageInfo_BlueGreenStatus proto.InternalMessageInfo func (m *BlueGreenStrategy) Reset() { *m = BlueGreenStrategy{} } func (*BlueGreenStrategy) ProtoMessage() {} func (*BlueGreenStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{24} + return fileDescriptor_e0e705f843545fab, []int{25} } func (m *BlueGreenStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -752,7 +780,7 @@ var xxx_messageInfo_BlueGreenStrategy proto.InternalMessageInfo func (m *CanaryStatus) Reset() { *m = CanaryStatus{} } func (*CanaryStatus) ProtoMessage() {} func (*CanaryStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{25} + return fileDescriptor_e0e705f843545fab, []int{26} } func (m *CanaryStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -780,7 +808,7 @@ var xxx_messageInfo_CanaryStatus proto.InternalMessageInfo func (m *CanaryStep) Reset() { *m = CanaryStep{} } func (*CanaryStep) ProtoMessage() {} func (*CanaryStep) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{26} + return fileDescriptor_e0e705f843545fab, []int{27} } func (m *CanaryStep) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -808,7 +836,7 @@ var xxx_messageInfo_CanaryStep proto.InternalMessageInfo func (m *CanaryStrategy) Reset() { *m = CanaryStrategy{} } func (*CanaryStrategy) ProtoMessage() {} func (*CanaryStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{27} + return fileDescriptor_e0e705f843545fab, []int{28} } func (m *CanaryStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -836,7 +864,7 @@ var xxx_messageInfo_CanaryStrategy proto.InternalMessageInfo func (m *CloudWatchMetric) Reset() { *m = CloudWatchMetric{} } func (*CloudWatchMetric) ProtoMessage() {} func (*CloudWatchMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{28} + return fileDescriptor_e0e705f843545fab, []int{29} } func (m *CloudWatchMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -864,7 +892,7 @@ var xxx_messageInfo_CloudWatchMetric proto.InternalMessageInfo func (m *CloudWatchMetricDataQuery) Reset() { *m = CloudWatchMetricDataQuery{} } func (*CloudWatchMetricDataQuery) ProtoMessage() {} func (*CloudWatchMetricDataQuery) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{29} + return fileDescriptor_e0e705f843545fab, []int{30} } func (m *CloudWatchMetricDataQuery) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -892,7 +920,7 @@ var xxx_messageInfo_CloudWatchMetricDataQuery proto.InternalMessageInfo func (m *CloudWatchMetricStat) Reset() { *m = CloudWatchMetricStat{} } func (*CloudWatchMetricStat) ProtoMessage() {} func (*CloudWatchMetricStat) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{30} + return fileDescriptor_e0e705f843545fab, []int{31} } func (m *CloudWatchMetricStat) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -920,7 +948,7 @@ var xxx_messageInfo_CloudWatchMetricStat proto.InternalMessageInfo func (m *CloudWatchMetricStatMetric) Reset() { *m = CloudWatchMetricStatMetric{} } func (*CloudWatchMetricStatMetric) ProtoMessage() {} func (*CloudWatchMetricStatMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{31} + return fileDescriptor_e0e705f843545fab, []int{32} } func (m *CloudWatchMetricStatMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -948,7 +976,7 @@ var xxx_messageInfo_CloudWatchMetricStatMetric proto.InternalMessageInfo func (m *CloudWatchMetricStatMetricDimension) Reset() { *m = CloudWatchMetricStatMetricDimension{} } func (*CloudWatchMetricStatMetricDimension) ProtoMessage() {} func (*CloudWatchMetricStatMetricDimension) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{32} + return fileDescriptor_e0e705f843545fab, []int{33} } func (m *CloudWatchMetricStatMetricDimension) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -976,7 +1004,7 @@ var xxx_messageInfo_CloudWatchMetricStatMetricDimension proto.InternalMessageInf func (m *ClusterAnalysisTemplate) Reset() { *m = ClusterAnalysisTemplate{} } func (*ClusterAnalysisTemplate) ProtoMessage() {} func (*ClusterAnalysisTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{33} + return fileDescriptor_e0e705f843545fab, []int{34} } func (m *ClusterAnalysisTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1004,7 +1032,7 @@ var xxx_messageInfo_ClusterAnalysisTemplate proto.InternalMessageInfo func (m *ClusterAnalysisTemplateList) Reset() { *m = ClusterAnalysisTemplateList{} } func (*ClusterAnalysisTemplateList) ProtoMessage() {} func (*ClusterAnalysisTemplateList) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{34} + return fileDescriptor_e0e705f843545fab, []int{35} } func (m *ClusterAnalysisTemplateList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1032,7 +1060,7 @@ var xxx_messageInfo_ClusterAnalysisTemplateList proto.InternalMessageInfo func (m *DatadogMetric) Reset() { *m = DatadogMetric{} } func (*DatadogMetric) ProtoMessage() {} func (*DatadogMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{35} + return fileDescriptor_e0e705f843545fab, []int{36} } func (m *DatadogMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1060,7 +1088,7 @@ var xxx_messageInfo_DatadogMetric proto.InternalMessageInfo func (m *DryRun) Reset() { *m = DryRun{} } func (*DryRun) ProtoMessage() {} func (*DryRun) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{36} + return fileDescriptor_e0e705f843545fab, []int{37} } func (m *DryRun) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1088,7 +1116,7 @@ var xxx_messageInfo_DryRun proto.InternalMessageInfo func (m *Experiment) Reset() { *m = Experiment{} } func (*Experiment) ProtoMessage() {} func (*Experiment) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{37} + return fileDescriptor_e0e705f843545fab, []int{38} } func (m *Experiment) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1116,7 +1144,7 @@ var xxx_messageInfo_Experiment proto.InternalMessageInfo func (m *ExperimentAnalysisRunStatus) Reset() { *m = ExperimentAnalysisRunStatus{} } func (*ExperimentAnalysisRunStatus) ProtoMessage() {} func (*ExperimentAnalysisRunStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{38} + return fileDescriptor_e0e705f843545fab, []int{39} } func (m *ExperimentAnalysisRunStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1144,7 +1172,7 @@ var xxx_messageInfo_ExperimentAnalysisRunStatus proto.InternalMessageInfo func (m *ExperimentAnalysisTemplateRef) Reset() { *m = ExperimentAnalysisTemplateRef{} } func (*ExperimentAnalysisTemplateRef) ProtoMessage() {} func (*ExperimentAnalysisTemplateRef) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{39} + return fileDescriptor_e0e705f843545fab, []int{40} } func (m *ExperimentAnalysisTemplateRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1172,7 +1200,7 @@ var xxx_messageInfo_ExperimentAnalysisTemplateRef proto.InternalMessageInfo func (m *ExperimentCondition) Reset() { *m = ExperimentCondition{} } func (*ExperimentCondition) ProtoMessage() {} func (*ExperimentCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{40} + return fileDescriptor_e0e705f843545fab, []int{41} } func (m *ExperimentCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1200,7 +1228,7 @@ var xxx_messageInfo_ExperimentCondition proto.InternalMessageInfo func (m *ExperimentList) Reset() { *m = ExperimentList{} } func (*ExperimentList) ProtoMessage() {} func (*ExperimentList) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{41} + return fileDescriptor_e0e705f843545fab, []int{42} } func (m *ExperimentList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1228,7 +1256,7 @@ var xxx_messageInfo_ExperimentList proto.InternalMessageInfo func (m *ExperimentSpec) Reset() { *m = ExperimentSpec{} } func (*ExperimentSpec) ProtoMessage() {} func (*ExperimentSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{42} + return fileDescriptor_e0e705f843545fab, []int{43} } func (m *ExperimentSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1256,7 +1284,7 @@ var xxx_messageInfo_ExperimentSpec proto.InternalMessageInfo func (m *ExperimentStatus) Reset() { *m = ExperimentStatus{} } func (*ExperimentStatus) ProtoMessage() {} func (*ExperimentStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{43} + return fileDescriptor_e0e705f843545fab, []int{44} } func (m *ExperimentStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1284,7 +1312,7 @@ var xxx_messageInfo_ExperimentStatus proto.InternalMessageInfo func (m *FieldRef) Reset() { *m = FieldRef{} } func (*FieldRef) ProtoMessage() {} func (*FieldRef) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{44} + return fileDescriptor_e0e705f843545fab, []int{45} } func (m *FieldRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1312,7 +1340,7 @@ var xxx_messageInfo_FieldRef proto.InternalMessageInfo func (m *GraphiteMetric) Reset() { *m = GraphiteMetric{} } func (*GraphiteMetric) ProtoMessage() {} func (*GraphiteMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{45} + return fileDescriptor_e0e705f843545fab, []int{46} } func (m *GraphiteMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1340,7 +1368,7 @@ var xxx_messageInfo_GraphiteMetric proto.InternalMessageInfo func (m *HeaderRoutingMatch) Reset() { *m = HeaderRoutingMatch{} } func (*HeaderRoutingMatch) ProtoMessage() {} func (*HeaderRoutingMatch) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{46} + return fileDescriptor_e0e705f843545fab, []int{47} } func (m *HeaderRoutingMatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1368,7 +1396,7 @@ var xxx_messageInfo_HeaderRoutingMatch proto.InternalMessageInfo func (m *InfluxdbMetric) Reset() { *m = InfluxdbMetric{} } func (*InfluxdbMetric) ProtoMessage() {} func (*InfluxdbMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{47} + return fileDescriptor_e0e705f843545fab, []int{48} } func (m *InfluxdbMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1396,7 +1424,7 @@ var xxx_messageInfo_InfluxdbMetric proto.InternalMessageInfo func (m *IstioDestinationRule) Reset() { *m = IstioDestinationRule{} } func (*IstioDestinationRule) ProtoMessage() {} func (*IstioDestinationRule) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{48} + return fileDescriptor_e0e705f843545fab, []int{49} } func (m *IstioDestinationRule) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1424,7 +1452,7 @@ var xxx_messageInfo_IstioDestinationRule proto.InternalMessageInfo func (m *IstioTrafficRouting) Reset() { *m = IstioTrafficRouting{} } func (*IstioTrafficRouting) ProtoMessage() {} func (*IstioTrafficRouting) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{49} + return fileDescriptor_e0e705f843545fab, []int{50} } func (m *IstioTrafficRouting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1452,7 +1480,7 @@ var xxx_messageInfo_IstioTrafficRouting proto.InternalMessageInfo func (m *IstioVirtualService) Reset() { *m = IstioVirtualService{} } func (*IstioVirtualService) ProtoMessage() {} func (*IstioVirtualService) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{50} + return fileDescriptor_e0e705f843545fab, []int{51} } func (m *IstioVirtualService) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1480,7 +1508,7 @@ var xxx_messageInfo_IstioVirtualService proto.InternalMessageInfo func (m *JobMetric) Reset() { *m = JobMetric{} } func (*JobMetric) ProtoMessage() {} func (*JobMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{51} + return fileDescriptor_e0e705f843545fab, []int{52} } func (m *JobMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1508,7 +1536,7 @@ var xxx_messageInfo_JobMetric proto.InternalMessageInfo func (m *KayentaMetric) Reset() { *m = KayentaMetric{} } func (*KayentaMetric) ProtoMessage() {} func (*KayentaMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{52} + return fileDescriptor_e0e705f843545fab, []int{53} } func (m *KayentaMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1536,7 +1564,7 @@ var xxx_messageInfo_KayentaMetric proto.InternalMessageInfo func (m *KayentaScope) Reset() { *m = KayentaScope{} } func (*KayentaScope) ProtoMessage() {} func (*KayentaScope) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{53} + return fileDescriptor_e0e705f843545fab, []int{54} } func (m *KayentaScope) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1564,7 +1592,7 @@ var xxx_messageInfo_KayentaScope proto.InternalMessageInfo func (m *KayentaThreshold) Reset() { *m = KayentaThreshold{} } func (*KayentaThreshold) ProtoMessage() {} func (*KayentaThreshold) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{54} + return fileDescriptor_e0e705f843545fab, []int{55} } func (m *KayentaThreshold) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1592,7 +1620,7 @@ var xxx_messageInfo_KayentaThreshold proto.InternalMessageInfo func (m *MangedRoutes) Reset() { *m = MangedRoutes{} } func (*MangedRoutes) ProtoMessage() {} func (*MangedRoutes) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{55} + return fileDescriptor_e0e705f843545fab, []int{56} } func (m *MangedRoutes) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1620,7 +1648,7 @@ var xxx_messageInfo_MangedRoutes proto.InternalMessageInfo func (m *Measurement) Reset() { *m = Measurement{} } func (*Measurement) ProtoMessage() {} func (*Measurement) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{56} + return fileDescriptor_e0e705f843545fab, []int{57} } func (m *Measurement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1648,7 +1676,7 @@ var xxx_messageInfo_Measurement proto.InternalMessageInfo func (m *MeasurementRetention) Reset() { *m = MeasurementRetention{} } func (*MeasurementRetention) ProtoMessage() {} func (*MeasurementRetention) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{57} + return fileDescriptor_e0e705f843545fab, []int{58} } func (m *MeasurementRetention) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1676,7 +1704,7 @@ var xxx_messageInfo_MeasurementRetention proto.InternalMessageInfo func (m *Metric) Reset() { *m = Metric{} } func (*Metric) ProtoMessage() {} func (*Metric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{58} + return fileDescriptor_e0e705f843545fab, []int{59} } func (m *Metric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1704,7 +1732,7 @@ var xxx_messageInfo_Metric proto.InternalMessageInfo func (m *MetricProvider) Reset() { *m = MetricProvider{} } func (*MetricProvider) ProtoMessage() {} func (*MetricProvider) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{59} + return fileDescriptor_e0e705f843545fab, []int{60} } func (m *MetricProvider) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1732,7 +1760,7 @@ var xxx_messageInfo_MetricProvider proto.InternalMessageInfo func (m *MetricResult) Reset() { *m = MetricResult{} } func (*MetricResult) ProtoMessage() {} func (*MetricResult) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{60} + return fileDescriptor_e0e705f843545fab, []int{61} } func (m *MetricResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1760,7 +1788,7 @@ var xxx_messageInfo_MetricResult proto.InternalMessageInfo func (m *NewRelicMetric) Reset() { *m = NewRelicMetric{} } func (*NewRelicMetric) ProtoMessage() {} func (*NewRelicMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{61} + return fileDescriptor_e0e705f843545fab, []int{62} } func (m *NewRelicMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1788,7 +1816,7 @@ var xxx_messageInfo_NewRelicMetric proto.InternalMessageInfo func (m *NginxTrafficRouting) Reset() { *m = NginxTrafficRouting{} } func (*NginxTrafficRouting) ProtoMessage() {} func (*NginxTrafficRouting) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{62} + return fileDescriptor_e0e705f843545fab, []int{63} } func (m *NginxTrafficRouting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1813,10 +1841,38 @@ func (m *NginxTrafficRouting) XXX_DiscardUnknown() { var xxx_messageInfo_NginxTrafficRouting proto.InternalMessageInfo +func (m *OAuth2Config) Reset() { *m = OAuth2Config{} } +func (*OAuth2Config) ProtoMessage() {} +func (*OAuth2Config) Descriptor() ([]byte, []int) { + return fileDescriptor_e0e705f843545fab, []int{64} +} +func (m *OAuth2Config) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OAuth2Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *OAuth2Config) XXX_Merge(src proto.Message) { + xxx_messageInfo_OAuth2Config.Merge(m, src) +} +func (m *OAuth2Config) XXX_Size() int { + return m.Size() +} +func (m *OAuth2Config) XXX_DiscardUnknown() { + xxx_messageInfo_OAuth2Config.DiscardUnknown(m) +} + +var xxx_messageInfo_OAuth2Config proto.InternalMessageInfo + func (m *ObjectRef) Reset() { *m = ObjectRef{} } func (*ObjectRef) ProtoMessage() {} func (*ObjectRef) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{63} + return fileDescriptor_e0e705f843545fab, []int{65} } func (m *ObjectRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1844,7 +1900,7 @@ var xxx_messageInfo_ObjectRef proto.InternalMessageInfo func (m *PauseCondition) Reset() { *m = PauseCondition{} } func (*PauseCondition) ProtoMessage() {} func (*PauseCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{64} + return fileDescriptor_e0e705f843545fab, []int{66} } func (m *PauseCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1872,7 +1928,7 @@ var xxx_messageInfo_PauseCondition proto.InternalMessageInfo func (m *PingPongSpec) Reset() { *m = PingPongSpec{} } func (*PingPongSpec) ProtoMessage() {} func (*PingPongSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{65} + return fileDescriptor_e0e705f843545fab, []int{67} } func (m *PingPongSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1900,7 +1956,7 @@ var xxx_messageInfo_PingPongSpec proto.InternalMessageInfo func (m *PodTemplateMetadata) Reset() { *m = PodTemplateMetadata{} } func (*PodTemplateMetadata) ProtoMessage() {} func (*PodTemplateMetadata) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{66} + return fileDescriptor_e0e705f843545fab, []int{68} } func (m *PodTemplateMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1930,7 +1986,7 @@ func (m *PreferredDuringSchedulingIgnoredDuringExecution) Reset() { } func (*PreferredDuringSchedulingIgnoredDuringExecution) ProtoMessage() {} func (*PreferredDuringSchedulingIgnoredDuringExecution) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{67} + return fileDescriptor_e0e705f843545fab, []int{69} } func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1955,38 +2011,10 @@ func (m *PreferredDuringSchedulingIgnoredDuringExecution) XXX_DiscardUnknown() { var xxx_messageInfo_PreferredDuringSchedulingIgnoredDuringExecution proto.InternalMessageInfo -func (m *PrometheusAuth) Reset() { *m = PrometheusAuth{} } -func (*PrometheusAuth) ProtoMessage() {} -func (*PrometheusAuth) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{68} -} -func (m *PrometheusAuth) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *PrometheusAuth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil -} -func (m *PrometheusAuth) XXX_Merge(src proto.Message) { - xxx_messageInfo_PrometheusAuth.Merge(m, src) -} -func (m *PrometheusAuth) XXX_Size() int { - return m.Size() -} -func (m *PrometheusAuth) XXX_DiscardUnknown() { - xxx_messageInfo_PrometheusAuth.DiscardUnknown(m) -} - -var xxx_messageInfo_PrometheusAuth proto.InternalMessageInfo - func (m *PrometheusMetric) Reset() { *m = PrometheusMetric{} } func (*PrometheusMetric) ProtoMessage() {} func (*PrometheusMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{69} + return fileDescriptor_e0e705f843545fab, []int{70} } func (m *PrometheusMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2016,7 +2044,7 @@ func (m *RequiredDuringSchedulingIgnoredDuringExecution) Reset() { } func (*RequiredDuringSchedulingIgnoredDuringExecution) ProtoMessage() {} func (*RequiredDuringSchedulingIgnoredDuringExecution) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{70} + return fileDescriptor_e0e705f843545fab, []int{71} } func (m *RequiredDuringSchedulingIgnoredDuringExecution) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2044,7 +2072,7 @@ var xxx_messageInfo_RequiredDuringSchedulingIgnoredDuringExecution proto.Interna func (m *RollbackWindowSpec) Reset() { *m = RollbackWindowSpec{} } func (*RollbackWindowSpec) ProtoMessage() {} func (*RollbackWindowSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{71} + return fileDescriptor_e0e705f843545fab, []int{72} } func (m *RollbackWindowSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2072,7 +2100,7 @@ var xxx_messageInfo_RollbackWindowSpec proto.InternalMessageInfo func (m *Rollout) Reset() { *m = Rollout{} } func (*Rollout) ProtoMessage() {} func (*Rollout) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{72} + return fileDescriptor_e0e705f843545fab, []int{73} } func (m *Rollout) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2100,7 +2128,7 @@ var xxx_messageInfo_Rollout proto.InternalMessageInfo func (m *RolloutAnalysis) Reset() { *m = RolloutAnalysis{} } func (*RolloutAnalysis) ProtoMessage() {} func (*RolloutAnalysis) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{73} + return fileDescriptor_e0e705f843545fab, []int{74} } func (m *RolloutAnalysis) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2128,7 +2156,7 @@ var xxx_messageInfo_RolloutAnalysis proto.InternalMessageInfo func (m *RolloutAnalysisBackground) Reset() { *m = RolloutAnalysisBackground{} } func (*RolloutAnalysisBackground) ProtoMessage() {} func (*RolloutAnalysisBackground) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{74} + return fileDescriptor_e0e705f843545fab, []int{75} } func (m *RolloutAnalysisBackground) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2156,7 +2184,7 @@ var xxx_messageInfo_RolloutAnalysisBackground proto.InternalMessageInfo func (m *RolloutAnalysisRunStatus) Reset() { *m = RolloutAnalysisRunStatus{} } func (*RolloutAnalysisRunStatus) ProtoMessage() {} func (*RolloutAnalysisRunStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{75} + return fileDescriptor_e0e705f843545fab, []int{76} } func (m *RolloutAnalysisRunStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2184,7 +2212,7 @@ var xxx_messageInfo_RolloutAnalysisRunStatus proto.InternalMessageInfo func (m *RolloutAnalysisTemplate) Reset() { *m = RolloutAnalysisTemplate{} } func (*RolloutAnalysisTemplate) ProtoMessage() {} func (*RolloutAnalysisTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{76} + return fileDescriptor_e0e705f843545fab, []int{77} } func (m *RolloutAnalysisTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2212,7 +2240,7 @@ var xxx_messageInfo_RolloutAnalysisTemplate proto.InternalMessageInfo func (m *RolloutCondition) Reset() { *m = RolloutCondition{} } func (*RolloutCondition) ProtoMessage() {} func (*RolloutCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{77} + return fileDescriptor_e0e705f843545fab, []int{78} } func (m *RolloutCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2240,7 +2268,7 @@ var xxx_messageInfo_RolloutCondition proto.InternalMessageInfo func (m *RolloutExperimentStep) Reset() { *m = RolloutExperimentStep{} } func (*RolloutExperimentStep) ProtoMessage() {} func (*RolloutExperimentStep) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{78} + return fileDescriptor_e0e705f843545fab, []int{79} } func (m *RolloutExperimentStep) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2270,7 +2298,7 @@ func (m *RolloutExperimentStepAnalysisTemplateRef) Reset() { } func (*RolloutExperimentStepAnalysisTemplateRef) ProtoMessage() {} func (*RolloutExperimentStepAnalysisTemplateRef) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{79} + return fileDescriptor_e0e705f843545fab, []int{80} } func (m *RolloutExperimentStepAnalysisTemplateRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2298,7 +2326,7 @@ var xxx_messageInfo_RolloutExperimentStepAnalysisTemplateRef proto.InternalMessa func (m *RolloutExperimentTemplate) Reset() { *m = RolloutExperimentTemplate{} } func (*RolloutExperimentTemplate) ProtoMessage() {} func (*RolloutExperimentTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{80} + return fileDescriptor_e0e705f843545fab, []int{81} } func (m *RolloutExperimentTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2326,7 +2354,7 @@ var xxx_messageInfo_RolloutExperimentTemplate proto.InternalMessageInfo func (m *RolloutList) Reset() { *m = RolloutList{} } func (*RolloutList) ProtoMessage() {} func (*RolloutList) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{81} + return fileDescriptor_e0e705f843545fab, []int{82} } func (m *RolloutList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2354,7 +2382,7 @@ var xxx_messageInfo_RolloutList proto.InternalMessageInfo func (m *RolloutPause) Reset() { *m = RolloutPause{} } func (*RolloutPause) ProtoMessage() {} func (*RolloutPause) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{82} + return fileDescriptor_e0e705f843545fab, []int{83} } func (m *RolloutPause) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2382,7 +2410,7 @@ var xxx_messageInfo_RolloutPause proto.InternalMessageInfo func (m *RolloutSpec) Reset() { *m = RolloutSpec{} } func (*RolloutSpec) ProtoMessage() {} func (*RolloutSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{83} + return fileDescriptor_e0e705f843545fab, []int{84} } func (m *RolloutSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2410,7 +2438,7 @@ var xxx_messageInfo_RolloutSpec proto.InternalMessageInfo func (m *RolloutStatus) Reset() { *m = RolloutStatus{} } func (*RolloutStatus) ProtoMessage() {} func (*RolloutStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{84} + return fileDescriptor_e0e705f843545fab, []int{85} } func (m *RolloutStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2438,7 +2466,7 @@ var xxx_messageInfo_RolloutStatus proto.InternalMessageInfo func (m *RolloutStrategy) Reset() { *m = RolloutStrategy{} } func (*RolloutStrategy) ProtoMessage() {} func (*RolloutStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{85} + return fileDescriptor_e0e705f843545fab, []int{86} } func (m *RolloutStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2466,7 +2494,7 @@ var xxx_messageInfo_RolloutStrategy proto.InternalMessageInfo func (m *RolloutTrafficRouting) Reset() { *m = RolloutTrafficRouting{} } func (*RolloutTrafficRouting) ProtoMessage() {} func (*RolloutTrafficRouting) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{86} + return fileDescriptor_e0e705f843545fab, []int{87} } func (m *RolloutTrafficRouting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2494,7 +2522,7 @@ var xxx_messageInfo_RolloutTrafficRouting proto.InternalMessageInfo func (m *RouteMatch) Reset() { *m = RouteMatch{} } func (*RouteMatch) ProtoMessage() {} func (*RouteMatch) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{87} + return fileDescriptor_e0e705f843545fab, []int{88} } func (m *RouteMatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2522,7 +2550,7 @@ var xxx_messageInfo_RouteMatch proto.InternalMessageInfo func (m *RunSummary) Reset() { *m = RunSummary{} } func (*RunSummary) ProtoMessage() {} func (*RunSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{88} + return fileDescriptor_e0e705f843545fab, []int{89} } func (m *RunSummary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2550,7 +2578,7 @@ var xxx_messageInfo_RunSummary proto.InternalMessageInfo func (m *SMITrafficRouting) Reset() { *m = SMITrafficRouting{} } func (*SMITrafficRouting) ProtoMessage() {} func (*SMITrafficRouting) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{89} + return fileDescriptor_e0e705f843545fab, []int{90} } func (m *SMITrafficRouting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2578,7 +2606,7 @@ var xxx_messageInfo_SMITrafficRouting proto.InternalMessageInfo func (m *ScopeDetail) Reset() { *m = ScopeDetail{} } func (*ScopeDetail) ProtoMessage() {} func (*ScopeDetail) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{90} + return fileDescriptor_e0e705f843545fab, []int{91} } func (m *ScopeDetail) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2606,7 +2634,7 @@ var xxx_messageInfo_ScopeDetail proto.InternalMessageInfo func (m *SecretKeyRef) Reset() { *m = SecretKeyRef{} } func (*SecretKeyRef) ProtoMessage() {} func (*SecretKeyRef) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{91} + return fileDescriptor_e0e705f843545fab, []int{92} } func (m *SecretKeyRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2634,7 +2662,7 @@ var xxx_messageInfo_SecretKeyRef proto.InternalMessageInfo func (m *SetCanaryScale) Reset() { *m = SetCanaryScale{} } func (*SetCanaryScale) ProtoMessage() {} func (*SetCanaryScale) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{92} + return fileDescriptor_e0e705f843545fab, []int{93} } func (m *SetCanaryScale) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2662,7 +2690,7 @@ var xxx_messageInfo_SetCanaryScale proto.InternalMessageInfo func (m *SetHeaderRoute) Reset() { *m = SetHeaderRoute{} } func (*SetHeaderRoute) ProtoMessage() {} func (*SetHeaderRoute) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{93} + return fileDescriptor_e0e705f843545fab, []int{94} } func (m *SetHeaderRoute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2690,7 +2718,7 @@ var xxx_messageInfo_SetHeaderRoute proto.InternalMessageInfo func (m *SetMirrorRoute) Reset() { *m = SetMirrorRoute{} } func (*SetMirrorRoute) ProtoMessage() {} func (*SetMirrorRoute) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{94} + return fileDescriptor_e0e705f843545fab, []int{95} } func (m *SetMirrorRoute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2718,7 +2746,7 @@ var xxx_messageInfo_SetMirrorRoute proto.InternalMessageInfo func (m *Sigv4Config) Reset() { *m = Sigv4Config{} } func (*Sigv4Config) ProtoMessage() {} func (*Sigv4Config) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{95} + return fileDescriptor_e0e705f843545fab, []int{96} } func (m *Sigv4Config) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2746,7 +2774,7 @@ var xxx_messageInfo_Sigv4Config proto.InternalMessageInfo func (m *SkyWalkingMetric) Reset() { *m = SkyWalkingMetric{} } func (*SkyWalkingMetric) ProtoMessage() {} func (*SkyWalkingMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{96} + return fileDescriptor_e0e705f843545fab, []int{97} } func (m *SkyWalkingMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2774,7 +2802,7 @@ var xxx_messageInfo_SkyWalkingMetric proto.InternalMessageInfo func (m *StickinessConfig) Reset() { *m = StickinessConfig{} } func (*StickinessConfig) ProtoMessage() {} func (*StickinessConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{97} + return fileDescriptor_e0e705f843545fab, []int{98} } func (m *StickinessConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2802,7 +2830,7 @@ var xxx_messageInfo_StickinessConfig proto.InternalMessageInfo func (m *StringMatch) Reset() { *m = StringMatch{} } func (*StringMatch) ProtoMessage() {} func (*StringMatch) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{98} + return fileDescriptor_e0e705f843545fab, []int{99} } func (m *StringMatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2830,7 +2858,7 @@ var xxx_messageInfo_StringMatch proto.InternalMessageInfo func (m *TCPRoute) Reset() { *m = TCPRoute{} } func (*TCPRoute) ProtoMessage() {} func (*TCPRoute) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{99} + return fileDescriptor_e0e705f843545fab, []int{100} } func (m *TCPRoute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2858,7 +2886,7 @@ var xxx_messageInfo_TCPRoute proto.InternalMessageInfo func (m *TLSRoute) Reset() { *m = TLSRoute{} } func (*TLSRoute) ProtoMessage() {} func (*TLSRoute) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{100} + return fileDescriptor_e0e705f843545fab, []int{101} } func (m *TLSRoute) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2886,7 +2914,7 @@ var xxx_messageInfo_TLSRoute proto.InternalMessageInfo func (m *TemplateService) Reset() { *m = TemplateService{} } func (*TemplateService) ProtoMessage() {} func (*TemplateService) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{101} + return fileDescriptor_e0e705f843545fab, []int{102} } func (m *TemplateService) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2914,7 +2942,7 @@ var xxx_messageInfo_TemplateService proto.InternalMessageInfo func (m *TemplateSpec) Reset() { *m = TemplateSpec{} } func (*TemplateSpec) ProtoMessage() {} func (*TemplateSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{102} + return fileDescriptor_e0e705f843545fab, []int{103} } func (m *TemplateSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2942,7 +2970,7 @@ var xxx_messageInfo_TemplateSpec proto.InternalMessageInfo func (m *TemplateStatus) Reset() { *m = TemplateStatus{} } func (*TemplateStatus) ProtoMessage() {} func (*TemplateStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{103} + return fileDescriptor_e0e705f843545fab, []int{104} } func (m *TemplateStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2970,7 +2998,7 @@ var xxx_messageInfo_TemplateStatus proto.InternalMessageInfo func (m *TraefikTrafficRouting) Reset() { *m = TraefikTrafficRouting{} } func (*TraefikTrafficRouting) ProtoMessage() {} func (*TraefikTrafficRouting) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{104} + return fileDescriptor_e0e705f843545fab, []int{105} } func (m *TraefikTrafficRouting) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2998,7 +3026,7 @@ var xxx_messageInfo_TraefikTrafficRouting proto.InternalMessageInfo func (m *TrafficWeights) Reset() { *m = TrafficWeights{} } func (*TrafficWeights) ProtoMessage() {} func (*TrafficWeights) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{105} + return fileDescriptor_e0e705f843545fab, []int{106} } func (m *TrafficWeights) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3026,7 +3054,7 @@ var xxx_messageInfo_TrafficWeights proto.InternalMessageInfo func (m *ValueFrom) Reset() { *m = ValueFrom{} } func (*ValueFrom) ProtoMessage() {} func (*ValueFrom) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{106} + return fileDescriptor_e0e705f843545fab, []int{107} } func (m *ValueFrom) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3054,7 +3082,7 @@ var xxx_messageInfo_ValueFrom proto.InternalMessageInfo func (m *WavefrontMetric) Reset() { *m = WavefrontMetric{} } func (*WavefrontMetric) ProtoMessage() {} func (*WavefrontMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{107} + return fileDescriptor_e0e705f843545fab, []int{108} } func (m *WavefrontMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3082,7 +3110,7 @@ var xxx_messageInfo_WavefrontMetric proto.InternalMessageInfo func (m *WebMetric) Reset() { *m = WebMetric{} } func (*WebMetric) ProtoMessage() {} func (*WebMetric) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{108} + return fileDescriptor_e0e705f843545fab, []int{109} } func (m *WebMetric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3110,7 +3138,7 @@ var xxx_messageInfo_WebMetric proto.InternalMessageInfo func (m *WebMetricHeader) Reset() { *m = WebMetricHeader{} } func (*WebMetricHeader) ProtoMessage() {} func (*WebMetricHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{109} + return fileDescriptor_e0e705f843545fab, []int{110} } func (m *WebMetricHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3138,7 +3166,7 @@ var xxx_messageInfo_WebMetricHeader proto.InternalMessageInfo func (m *WeightDestination) Reset() { *m = WeightDestination{} } func (*WeightDestination) ProtoMessage() {} func (*WeightDestination) Descriptor() ([]byte, []int) { - return fileDescriptor_e0e705f843545fab, []int{110} + return fileDescriptor_e0e705f843545fab, []int{111} } func (m *WeightDestination) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3188,6 +3216,7 @@ func init() { proto.RegisterType((*AppMeshVirtualService)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AppMeshVirtualService") proto.RegisterType((*Argument)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Argument") proto.RegisterType((*ArgumentValueFrom)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ArgumentValueFrom") + proto.RegisterType((*Authentication)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.Authentication") proto.RegisterType((*AwsResourceRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.AwsResourceRef") proto.RegisterType((*BlueGreenStatus)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.BlueGreenStatus") proto.RegisterType((*BlueGreenStrategy)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.BlueGreenStrategy") @@ -3233,6 +3262,7 @@ func init() { proto.RegisterType((*NewRelicMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NewRelicMetric") proto.RegisterType((*NginxTrafficRouting)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting") proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.NginxTrafficRouting.AdditionalIngressAnnotationsEntry") + proto.RegisterType((*OAuth2Config)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.OAuth2Config") proto.RegisterType((*ObjectRef)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.ObjectRef") proto.RegisterType((*PauseCondition)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PauseCondition") proto.RegisterType((*PingPongSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PingPongSpec") @@ -3240,7 +3270,6 @@ func init() { proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PodTemplateMetadata.LabelsEntry") proto.RegisterType((*PreferredDuringSchedulingIgnoredDuringExecution)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution") - proto.RegisterType((*PrometheusAuth)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PrometheusAuth") proto.RegisterType((*PrometheusMetric)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.PrometheusMetric") proto.RegisterType((*RequiredDuringSchedulingIgnoredDuringExecution)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution") proto.RegisterType((*RollbackWindowSpec)(nil), "github.com.argoproj.argo_rollouts.pkg.apis.rollouts.v1alpha1.RollbackWindowSpec") @@ -3292,521 +3321,528 @@ func init() { } var fileDescriptor_e0e705f843545fab = []byte{ - // 8214 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, 0x72, 0x1e, 0xb9, 0x24, 0xb7, 0x76, 0x57, 0xcb, 0xe3, 0xdd, 0xee, - 0x9c, 0xfa, 0x9c, 0xcb, 0xca, 0x3a, 0x91, 0xd2, 0x7d, 0x24, 0x27, 0x9d, 0x72, 0xc9, 0x0c, 0xb9, - 0x7b, 0xcb, 0x3d, 0x72, 0x6f, 0xf6, 0x0d, 0xf7, 0x56, 0x96, 0x74, 0xb6, 0x9a, 0x33, 0xc5, 0x61, - 0x2f, 0x67, 0xba, 0xc7, 0xdd, 0x3d, 0xdc, 0xe5, 0xe9, 0x60, 0x9d, 0x2c, 0x9c, 0xa2, 0x18, 0x12, - 0xac, 0xc4, 0x16, 0x82, 0x20, 0x41, 0xa0, 0x18, 0x06, 0xec, 0xc4, 0xfe, 0x25, 0x24, 0xc8, 0x1f, - 0x03, 0x11, 0xe2, 0xd8, 0xd6, 0x8f, 0x38, 0x90, 0x7f, 0x24, 0xb2, 0x03, 0x98, 0x8e, 0xa8, 0xfc, - 0x49, 0x90, 0x40, 0x08, 0xe0, 0x20, 0xf0, 0xfe, 0x08, 0x82, 0xfa, 0xec, 0xea, 0x9e, 0x1e, 0xee, - 0xcc, 0x4e, 0x73, 0x75, 0x49, 0xfc, 0x6f, 0xa6, 0x5e, 0xd5, 0x7b, 0xaf, 0xeb, 0xe3, 0xd5, 0xab, - 0x57, 0xef, 0xbd, 0x82, 0xcd, 0x96, 0x1b, 0xed, 0xf5, 0x76, 0x56, 0x1a, 0x7e, 0x67, 0xd5, 0x09, - 0x5a, 0x7e, 0x37, 0xf0, 0xef, 0xf2, 0x1f, 0x1f, 0x0b, 0xfc, 0x76, 0xdb, 0xef, 0x45, 0xe1, 0x6a, - 0x77, 0xbf, 0xb5, 0xea, 0x74, 0xdd, 0x70, 0x55, 0x97, 0x1c, 0x7c, 0xc2, 0x69, 0x77, 0xf7, 0x9c, - 0x4f, 0xac, 0xb6, 0xa8, 0x47, 0x03, 0x27, 0xa2, 0xcd, 0x95, 0x6e, 0xe0, 0x47, 0x3e, 0xf9, 0x74, - 0x8c, 0x6d, 0x45, 0x61, 0xe3, 0x3f, 0x7e, 0x4e, 0xb5, 0x5d, 0xe9, 0xee, 0xb7, 0x56, 0x18, 0xb6, - 0x15, 0x5d, 0xa2, 0xb0, 0x2d, 0x7f, 0xcc, 0xe0, 0xa5, 0xe5, 0xb7, 0xfc, 0x55, 0x8e, 0x74, 0xa7, - 0xb7, 0xcb, 0xff, 0xf1, 0x3f, 0xfc, 0x97, 0x20, 0xb6, 0xfc, 0xec, 0xfe, 0x2b, 0xe1, 0x8a, 0xeb, - 0x33, 0xde, 0x56, 0x77, 0x9c, 0xa8, 0xb1, 0xb7, 0x7a, 0xd0, 0xc7, 0xd1, 0xb2, 0x6d, 0x54, 0x6a, - 0xf8, 0x01, 0xcd, 0xaa, 0xf3, 0x52, 0x5c, 0xa7, 0xe3, 0x34, 0xf6, 0x5c, 0x8f, 0x06, 0x87, 0xf1, - 0x57, 0x77, 0x68, 0xe4, 0x64, 0xb5, 0x5a, 0x1d, 0xd4, 0x2a, 0xe8, 0x79, 0x91, 0xdb, 0xa1, 0x7d, - 0x0d, 0xfe, 0xda, 0xc3, 0x1a, 0x84, 0x8d, 0x3d, 0xda, 0x71, 0xfa, 0xda, 0xbd, 0x38, 0xa8, 0x5d, - 0x2f, 0x72, 0xdb, 0xab, 0xae, 0x17, 0x85, 0x51, 0x90, 0x6e, 0x64, 0xff, 0xb8, 0x00, 0xa5, 0xca, - 0x66, 0xb5, 0x1e, 0x39, 0x51, 0x2f, 0x24, 0x5f, 0xb5, 0x60, 0xae, 0xed, 0x3b, 0xcd, 0xaa, 0xd3, - 0x76, 0xbc, 0x06, 0x0d, 0x96, 0xac, 0x67, 0xac, 0x2b, 0xb3, 0x2f, 0x6c, 0xae, 0x8c, 0x33, 0x5e, - 0x2b, 0x95, 0x7b, 0x21, 0xd2, 0xd0, 0xef, 0x05, 0x0d, 0x8a, 0x74, 0xb7, 0x7a, 0xfe, 0x7b, 0x47, - 0xe5, 0x27, 0x8e, 0x8f, 0xca, 0x73, 0x9b, 0x06, 0x25, 0x4c, 0xd0, 0x25, 0xdf, 0xb2, 0xe0, 0x6c, - 0xc3, 0xf1, 0x9c, 0xe0, 0x70, 0xdb, 0x09, 0x5a, 0x34, 0x7a, 0x3d, 0xf0, 0x7b, 0xdd, 0xa5, 0x89, - 0x53, 0xe0, 0xe6, 0x49, 0xc9, 0xcd, 0xd9, 0xb5, 0x34, 0x39, 0xec, 0xe7, 0x80, 0xf3, 0x15, 0x46, - 0xce, 0x4e, 0x9b, 0x9a, 0x7c, 0x15, 0x4e, 0x93, 0xaf, 0x7a, 0x9a, 0x1c, 0xf6, 0x73, 0x40, 0x3e, - 0x02, 0xd3, 0xae, 0xd7, 0x0a, 0x68, 0x18, 0x2e, 0x4d, 0x3e, 0x63, 0x5d, 0x29, 0x55, 0x17, 0x64, - 0xf3, 0xe9, 0x0d, 0x51, 0x8c, 0x0a, 0x6e, 0x7f, 0xa7, 0x00, 0x67, 0x2b, 0x9b, 0xd5, 0xed, 0xc0, - 0xd9, 0xdd, 0x75, 0x1b, 0xe8, 0xf7, 0x22, 0xd7, 0x6b, 0x99, 0x08, 0xac, 0x93, 0x11, 0x90, 0x97, - 0x61, 0x36, 0xa4, 0xc1, 0x81, 0xdb, 0xa0, 0x35, 0x3f, 0x88, 0xf8, 0xa0, 0x14, 0xab, 0xe7, 0x64, - 0xf5, 0xd9, 0x7a, 0x0c, 0x42, 0xb3, 0x1e, 0x6b, 0x16, 0xf8, 0x7e, 0x24, 0xe1, 0xbc, 0xcf, 0x4a, - 0x71, 0x33, 0x8c, 0x41, 0x68, 0xd6, 0x23, 0xeb, 0xb0, 0xe8, 0x78, 0x9e, 0x1f, 0x39, 0x91, 0xeb, - 0x7b, 0xb5, 0x80, 0xee, 0xba, 0xf7, 0xe5, 0x27, 0x2e, 0xc9, 0xb6, 0x8b, 0x95, 0x14, 0x1c, 0xfb, - 0x5a, 0x90, 0x6f, 0x5a, 0xb0, 0x18, 0x46, 0x6e, 0x63, 0xdf, 0xf5, 0x68, 0x18, 0xae, 0xf9, 0xde, - 0xae, 0xdb, 0x5a, 0x2a, 0xf2, 0x61, 0xbb, 0x39, 0xde, 0xb0, 0xd5, 0x53, 0x58, 0xab, 0xe7, 0x19, - 0x4b, 0xe9, 0x52, 0xec, 0xa3, 0x4e, 0x3e, 0x0a, 0x25, 0xd9, 0xa3, 0x34, 0x5c, 0x9a, 0x7a, 0xa6, - 0x70, 0xa5, 0x54, 0x3d, 0x73, 0x7c, 0x54, 0x2e, 0x6d, 0xa8, 0x42, 0x8c, 0xe1, 0xf6, 0x3a, 0x2c, - 0x55, 0x3a, 0x3b, 0x4e, 0x18, 0x3a, 0x4d, 0x3f, 0x48, 0x0d, 0xdd, 0x15, 0x98, 0xe9, 0x38, 0xdd, - 0xae, 0xeb, 0xb5, 0xd8, 0xd8, 0x31, 0x3c, 0x73, 0xc7, 0x47, 0xe5, 0x99, 0x2d, 0x59, 0x86, 0x1a, - 0x6a, 0xff, 0xc9, 0x04, 0xcc, 0x56, 0x3c, 0xa7, 0x7d, 0x18, 0xba, 0x21, 0xf6, 0x3c, 0xf2, 0x05, - 0x98, 0x61, 0x52, 0xab, 0xe9, 0x44, 0x8e, 0x5c, 0xe9, 0x1f, 0x5f, 0x11, 0x42, 0x64, 0xc5, 0x14, - 0x22, 0xf1, 0xe7, 0xb3, 0xda, 0x2b, 0x07, 0x9f, 0x58, 0x79, 0x73, 0xe7, 0x2e, 0x6d, 0x44, 0x5b, - 0x34, 0x72, 0xaa, 0x44, 0x8e, 0x02, 0xc4, 0x65, 0xa8, 0xb1, 0x12, 0x1f, 0x26, 0xc3, 0x2e, 0x6d, - 0xc8, 0x95, 0xbb, 0x35, 0xe6, 0x0a, 0x89, 0x59, 0xaf, 0x77, 0x69, 0xa3, 0x3a, 0x27, 0x49, 0x4f, - 0xb2, 0x7f, 0xc8, 0x09, 0x91, 0x7b, 0x30, 0x15, 0x72, 0x59, 0x26, 0x17, 0xe5, 0x9b, 0xf9, 0x91, - 0xe4, 0x68, 0xab, 0xf3, 0x92, 0xe8, 0x94, 0xf8, 0x8f, 0x92, 0x9c, 0xfd, 0x1f, 0x2d, 0x38, 0x67, - 0xd4, 0xae, 0x04, 0xad, 0x5e, 0x87, 0x7a, 0x11, 0x79, 0x06, 0x26, 0x3d, 0xa7, 0x43, 0xe5, 0xaa, - 0xd2, 0x2c, 0xdf, 0x74, 0x3a, 0x14, 0x39, 0x84, 0x3c, 0x0b, 0xc5, 0x03, 0xa7, 0xdd, 0xa3, 0xbc, - 0x93, 0x4a, 0xd5, 0x33, 0xb2, 0x4a, 0xf1, 0x2d, 0x56, 0x88, 0x02, 0x46, 0xde, 0x85, 0x12, 0xff, - 0x71, 0x2d, 0xf0, 0x3b, 0x39, 0x7d, 0x9a, 0xe4, 0xf0, 0x2d, 0x85, 0x56, 0x4c, 0x3f, 0xfd, 0x17, - 0x63, 0x82, 0xf6, 0x9f, 0x59, 0xb0, 0x60, 0x7c, 0xdc, 0xa6, 0x1b, 0x46, 0xe4, 0xf3, 0x7d, 0x93, - 0x67, 0x65, 0xb8, 0xc9, 0xc3, 0x5a, 0xf3, 0xa9, 0xb3, 0x28, 0xbf, 0x74, 0x46, 0x95, 0x18, 0x13, - 0xc7, 0x83, 0xa2, 0x1b, 0xd1, 0x4e, 0xb8, 0x34, 0xf1, 0x4c, 0xe1, 0xca, 0xec, 0x0b, 0x1b, 0xb9, - 0x0d, 0x63, 0xdc, 0xbf, 0x1b, 0x0c, 0x3f, 0x0a, 0x32, 0xf6, 0x3f, 0x2f, 0x24, 0x86, 0x6f, 0x4b, - 0xf1, 0xf1, 0xbe, 0x05, 0x53, 0x6d, 0x67, 0x87, 0xb6, 0xc5, 0xda, 0x9a, 0x7d, 0xe1, 0xed, 0xdc, - 0x38, 0x51, 0x34, 0x56, 0x36, 0x39, 0xfe, 0xab, 0x5e, 0x14, 0x1c, 0xc6, 0xd3, 0x4b, 0x14, 0xa2, - 0x24, 0x4e, 0xfe, 0x81, 0x05, 0xb3, 0xb1, 0x54, 0x53, 0xdd, 0xb2, 0x93, 0x3f, 0x33, 0xb1, 0x30, - 0x95, 0x1c, 0x69, 0x11, 0x6d, 0x40, 0xd0, 0xe4, 0x65, 0xf9, 0x93, 0x30, 0x6b, 0x7c, 0x02, 0x59, - 0x84, 0xc2, 0x3e, 0x3d, 0x14, 0x13, 0x1e, 0xd9, 0x4f, 0x72, 0x3e, 0x31, 0xc3, 0xe5, 0x94, 0xfe, - 0xd4, 0xc4, 0x2b, 0xd6, 0xf2, 0x6b, 0xb0, 0x98, 0x26, 0x38, 0x4a, 0x7b, 0xfb, 0x3b, 0x93, 0x89, - 0x89, 0xc9, 0x04, 0x01, 0xf1, 0x61, 0xba, 0x43, 0xa3, 0xc0, 0x6d, 0xa8, 0x21, 0x5b, 0x1f, 0xaf, - 0x97, 0xb6, 0x38, 0xb2, 0x78, 0x43, 0x14, 0xff, 0x43, 0x54, 0x54, 0xc8, 0x1e, 0x4c, 0x3a, 0x41, - 0x4b, 0x8d, 0xc9, 0xb5, 0x7c, 0x96, 0x65, 0x2c, 0x2a, 0x2a, 0x41, 0x2b, 0x44, 0x4e, 0x81, 0xac, - 0x42, 0x29, 0xa2, 0x41, 0xc7, 0xf5, 0x9c, 0x48, 0xec, 0xa0, 0x33, 0xd5, 0xb3, 0xb2, 0x5a, 0x69, - 0x5b, 0x01, 0x30, 0xae, 0x43, 0xda, 0x30, 0xd5, 0x0c, 0x0e, 0xb1, 0xe7, 0x2d, 0x4d, 0xe6, 0xd1, - 0x15, 0xeb, 0x1c, 0x57, 0x3c, 0x49, 0xc5, 0x7f, 0x94, 0x34, 0xc8, 0xaf, 0x5b, 0x70, 0xbe, 0x43, - 0x9d, 0xb0, 0x17, 0x50, 0xf6, 0x09, 0x48, 0x23, 0xea, 0xb1, 0x81, 0x5d, 0x2a, 0x72, 0xe2, 0x38, - 0xee, 0x38, 0xf4, 0x63, 0xae, 0x3e, 0x2d, 0x59, 0x39, 0x9f, 0x05, 0xc5, 0x4c, 0x6e, 0xec, 0x3f, - 0x99, 0x84, 0xb3, 0x7d, 0x82, 0x9d, 0xbc, 0x04, 0xc5, 0xee, 0x9e, 0x13, 0x2a, 0x49, 0x7d, 0x59, - 0x89, 0x89, 0x1a, 0x2b, 0x7c, 0x70, 0x54, 0x3e, 0xa3, 0x9a, 0xf0, 0x02, 0x14, 0x95, 0x99, 0xde, - 0xd4, 0xa1, 0x61, 0xe8, 0xb4, 0x94, 0xf8, 0x36, 0xa6, 0x09, 0x2f, 0x46, 0x05, 0x27, 0x7f, 0xdb, - 0x82, 0x33, 0x62, 0xca, 0x20, 0x0d, 0x7b, 0xed, 0x88, 0x6d, 0x51, 0xac, 0x5b, 0x6e, 0xe4, 0x31, - 0x3d, 0x05, 0xca, 0xea, 0x05, 0x49, 0xfd, 0x8c, 0x59, 0x1a, 0x62, 0x92, 0x2e, 0xb9, 0x03, 0xa5, - 0x30, 0x72, 0x82, 0x88, 0x36, 0x2b, 0x11, 0x57, 0xa6, 0x66, 0x5f, 0xf8, 0xe9, 0xe1, 0x64, 0xf7, - 0xb6, 0xdb, 0xa1, 0x62, 0x9f, 0xa8, 0x2b, 0x04, 0x18, 0xe3, 0x22, 0xef, 0x02, 0x04, 0x3d, 0xaf, - 0xde, 0xeb, 0x74, 0x9c, 0xe0, 0x50, 0xea, 0x57, 0xd7, 0xc7, 0xfb, 0x3c, 0xd4, 0xf8, 0x62, 0x55, - 0x23, 0x2e, 0x43, 0x83, 0x1e, 0xf9, 0xb2, 0x05, 0x67, 0xc4, 0x4c, 0x54, 0x1c, 0x4c, 0xe5, 0xcc, - 0xc1, 0x59, 0xd6, 0xb5, 0xeb, 0x26, 0x09, 0x4c, 0x52, 0xb4, 0xff, 0x7d, 0x52, 0x0d, 0xa8, 0x47, - 0xec, 0xb0, 0xd5, 0x3a, 0x24, 0x9f, 0x83, 0x27, 0xc3, 0x5e, 0xa3, 0x41, 0xc3, 0x70, 0xb7, 0xd7, - 0xc6, 0x9e, 0x77, 0xdd, 0x0d, 0x23, 0x3f, 0x38, 0xdc, 0x74, 0x3b, 0x6e, 0xc4, 0x67, 0x5c, 0xb1, - 0x7a, 0xe9, 0xf8, 0xa8, 0xfc, 0x64, 0x7d, 0x50, 0x25, 0x1c, 0xdc, 0x9e, 0x38, 0xf0, 0x54, 0xcf, - 0x1b, 0x8c, 0x5e, 0x68, 0xe8, 0xe5, 0xe3, 0xa3, 0xf2, 0x53, 0xb7, 0x07, 0x57, 0xc3, 0x93, 0x70, - 0xd8, 0xff, 0xd5, 0x62, 0x92, 0x5a, 0x7c, 0xd7, 0x36, 0xed, 0x74, 0xdb, 0x4c, 0xba, 0x9c, 0xbe, - 0xfe, 0x18, 0x25, 0xf4, 0x47, 0xcc, 0x67, 0xbb, 0x53, 0xfc, 0x0f, 0x52, 0x22, 0xed, 0xff, 0x62, - 0xc1, 0xf9, 0x74, 0xe5, 0xc7, 0xa0, 0xf3, 0x84, 0x49, 0x9d, 0xe7, 0x66, 0xbe, 0x5f, 0x3b, 0x40, - 0xf1, 0xf9, 0xea, 0x64, 0xff, 0xb7, 0xfe, 0xbf, 0xbe, 0x8d, 0xc6, 0xbb, 0x62, 0xe1, 0x27, 0xb9, - 0x2b, 0x4e, 0x7e, 0xa0, 0x76, 0xc5, 0xdf, 0x9c, 0x84, 0xb9, 0x8a, 0x17, 0xb9, 0x95, 0xdd, 0x5d, - 0xd7, 0x73, 0xa3, 0x43, 0xf2, 0xf5, 0x09, 0x58, 0xed, 0x06, 0x74, 0x97, 0x06, 0x01, 0x6d, 0xae, - 0xf7, 0x02, 0xd7, 0x6b, 0xd5, 0x1b, 0x7b, 0xb4, 0xd9, 0x6b, 0xbb, 0x5e, 0x6b, 0xa3, 0xe5, 0xf9, - 0xba, 0xf8, 0xea, 0x7d, 0xda, 0xe8, 0xf1, 0x4f, 0x12, 0x8b, 0xa2, 0x33, 0xde, 0x27, 0xd5, 0x46, - 0x23, 0x5a, 0x7d, 0xf1, 0xf8, 0xa8, 0xbc, 0x3a, 0x62, 0x23, 0x1c, 0xf5, 0xd3, 0xc8, 0xd7, 0x26, - 0x60, 0x25, 0xa0, 0x3f, 0xdf, 0x73, 0x87, 0xef, 0x0d, 0x21, 0xb5, 0xda, 0x63, 0x6e, 0x3f, 0x23, - 0xd1, 0xac, 0xbe, 0x70, 0x7c, 0x54, 0x1e, 0xb1, 0x0d, 0x8e, 0xf8, 0x5d, 0x76, 0x0d, 0x66, 0x2b, - 0x5d, 0x37, 0x74, 0xef, 0xa3, 0xdf, 0x8b, 0xe8, 0x10, 0x47, 0xdc, 0x32, 0x14, 0x83, 0x5e, 0x9b, - 0x8a, 0xb5, 0x5d, 0xaa, 0x96, 0x98, 0x14, 0x42, 0x56, 0x80, 0xa2, 0xdc, 0xfe, 0x45, 0x26, 0x71, - 0x39, 0xca, 0x94, 0x71, 0xe3, 0x2e, 0x14, 0x03, 0x46, 0x44, 0xce, 0xac, 0x71, 0xcf, 0x81, 0x31, - 0xd7, 0x92, 0x09, 0xf6, 0x13, 0x05, 0x09, 0xfb, 0x77, 0x27, 0xe0, 0x42, 0xa5, 0xdb, 0xdd, 0xa2, - 0xe1, 0x5e, 0x8a, 0x8b, 0x5f, 0xb6, 0x60, 0xfe, 0xc0, 0x0d, 0xa2, 0x9e, 0xd3, 0x56, 0xf6, 0x2b, - 0xc1, 0x4f, 0x7d, 0x5c, 0x7e, 0x38, 0xb5, 0xb7, 0x12, 0xa8, 0xab, 0xe4, 0xf8, 0xa8, 0x3c, 0x9f, - 0x2c, 0xc3, 0x14, 0x79, 0xf2, 0xf7, 0x2d, 0x58, 0x94, 0x45, 0x37, 0xfd, 0x26, 0x35, 0xed, 0xa3, - 0xb7, 0xf3, 0xe4, 0x49, 0x23, 0x17, 0x76, 0xad, 0x74, 0x29, 0xf6, 0x31, 0x61, 0xff, 0xf7, 0x09, - 0xb8, 0x38, 0x00, 0x07, 0xf9, 0x0d, 0x0b, 0xce, 0x0b, 0xa3, 0xaa, 0x01, 0x42, 0xba, 0x2b, 0x7b, - 0xf3, 0x67, 0xf2, 0xe6, 0x1c, 0xd9, 0x12, 0xa7, 0x5e, 0x83, 0x56, 0x97, 0x98, 0x34, 0x5c, 0xcb, - 0x20, 0x8d, 0x99, 0x0c, 0x71, 0x4e, 0x85, 0x99, 0x35, 0xc5, 0xe9, 0xc4, 0x63, 0xe1, 0xb4, 0x9e, - 0x41, 0x1a, 0x33, 0x19, 0xb2, 0xff, 0x26, 0x3c, 0x75, 0x02, 0xba, 0x87, 0x2f, 0x4e, 0xfb, 0x6d, - 0x3d, 0xeb, 0x93, 0x73, 0x6e, 0x88, 0x75, 0x6d, 0xc3, 0x14, 0x5f, 0x3a, 0x6a, 0x61, 0x03, 0xdb, - 0xfe, 0xf8, 0x9a, 0x0a, 0x51, 0x42, 0xec, 0xdf, 0xb5, 0x60, 0x66, 0x04, 0x6b, 0x58, 0x39, 0x69, - 0x0d, 0x2b, 0xf5, 0x59, 0xc2, 0xa2, 0x7e, 0x4b, 0xd8, 0xeb, 0xe3, 0x8d, 0xc6, 0x30, 0x16, 0xb0, - 0x1f, 0x5b, 0x70, 0xb6, 0xcf, 0x62, 0x46, 0xf6, 0xe0, 0x7c, 0xd7, 0x6f, 0x2a, 0xb5, 0xe9, 0xba, - 0x13, 0xee, 0x71, 0x98, 0xfc, 0xbc, 0x97, 0xd8, 0x48, 0xd6, 0x32, 0xe0, 0x0f, 0x8e, 0xca, 0x4b, - 0x1a, 0x49, 0xaa, 0x02, 0x66, 0x62, 0x24, 0x5d, 0x98, 0xd9, 0x75, 0x69, 0xbb, 0x19, 0x4f, 0xc1, - 0x31, 0x15, 0xa4, 0x6b, 0x12, 0x9b, 0x30, 0x16, 0xab, 0x7f, 0xa8, 0xa9, 0xd8, 0x5f, 0x82, 0xf9, - 0xe4, 0x95, 0xc4, 0x10, 0x83, 0x77, 0x09, 0x0a, 0x4e, 0xe0, 0xc9, 0xa1, 0x9b, 0x95, 0x15, 0x0a, - 0x15, 0xbc, 0x89, 0xac, 0x9c, 0x3c, 0x0f, 0x33, 0xbb, 0xbd, 0x76, 0x9b, 0x35, 0x90, 0xf6, 0x7f, - 0xad, 0x0e, 0x5f, 0x93, 0xe5, 0xa8, 0x6b, 0xd8, 0x7f, 0x31, 0x09, 0x0b, 0xd5, 0x76, 0x8f, 0xbe, - 0x1e, 0x50, 0xaa, 0x0e, 0xe9, 0x15, 0x58, 0xe8, 0x06, 0xf4, 0xc0, 0xa5, 0xf7, 0xea, 0xb4, 0x4d, - 0x1b, 0x91, 0x1f, 0x48, 0x6e, 0x2e, 0x4a, 0x44, 0x0b, 0xb5, 0x24, 0x18, 0xd3, 0xf5, 0xc9, 0x6b, - 0x30, 0xef, 0x34, 0x22, 0xf7, 0x80, 0x6a, 0x0c, 0x82, 0xdd, 0x0f, 0x49, 0x0c, 0xf3, 0x95, 0x04, - 0x14, 0x53, 0xb5, 0xc9, 0xe7, 0x61, 0x29, 0x6c, 0x38, 0x6d, 0x7a, 0xbb, 0x2b, 0x49, 0xad, 0xed, - 0xd1, 0xc6, 0x7e, 0xcd, 0x77, 0xbd, 0x48, 0x9a, 0x64, 0x9e, 0x91, 0x98, 0x96, 0xea, 0x03, 0xea, - 0xe1, 0x40, 0x0c, 0xe4, 0x5f, 0x59, 0x70, 0xa9, 0x1b, 0xd0, 0x5a, 0xe0, 0x77, 0x7c, 0xb6, 0xd7, - 0xf6, 0xd9, 0x29, 0xe4, 0x79, 0xfd, 0xad, 0x31, 0x95, 0x0a, 0x51, 0xd2, 0x6f, 0xde, 0xfe, 0xf0, - 0xf1, 0x51, 0xf9, 0x52, 0xed, 0x24, 0x06, 0xf0, 0x64, 0xfe, 0xc8, 0xbf, 0xb6, 0xe0, 0x72, 0xd7, - 0x0f, 0xa3, 0x13, 0x3e, 0xa1, 0x78, 0xaa, 0x9f, 0x60, 0x1f, 0x1f, 0x95, 0x2f, 0xd7, 0x4e, 0xe4, - 0x00, 0x1f, 0xc2, 0xa1, 0x7d, 0x3c, 0x0b, 0x67, 0x8d, 0xb9, 0x27, 0x0f, 0xf1, 0xaf, 0xc2, 0x19, - 0x35, 0x19, 0x62, 0x25, 0xa0, 0x14, 0x1b, 0x5d, 0x2a, 0x26, 0x10, 0x93, 0x75, 0xd9, 0xbc, 0xd3, - 0x53, 0x51, 0xb4, 0x4e, 0xcd, 0xbb, 0x5a, 0x02, 0x8a, 0xa9, 0xda, 0x64, 0x03, 0xce, 0xc9, 0x12, - 0xa4, 0xdd, 0xb6, 0xdb, 0x70, 0xd6, 0xfc, 0x9e, 0x9c, 0x72, 0xc5, 0xea, 0xc5, 0xe3, 0xa3, 0xf2, - 0xb9, 0x5a, 0x3f, 0x18, 0xb3, 0xda, 0x90, 0x4d, 0x38, 0xef, 0xf4, 0x22, 0x5f, 0x7f, 0xff, 0x55, - 0x8f, 0xed, 0x2b, 0x4d, 0x3e, 0xb5, 0x66, 0xc4, 0x06, 0x54, 0xc9, 0x80, 0x63, 0x66, 0x2b, 0x52, - 0x4b, 0x61, 0xab, 0xd3, 0x86, 0xef, 0x35, 0xc5, 0x28, 0x17, 0xe3, 0xa3, 0x48, 0x25, 0xa3, 0x0e, - 0x66, 0xb6, 0x24, 0x6d, 0x98, 0xef, 0x38, 0xf7, 0x6f, 0x7b, 0xce, 0x81, 0xe3, 0xb6, 0x19, 0x11, - 0x69, 0xc8, 0x19, 0x6c, 0x5d, 0xe8, 0x45, 0x6e, 0x7b, 0x45, 0x5c, 0x71, 0xaf, 0x6c, 0x78, 0xd1, - 0x9b, 0x41, 0x3d, 0x62, 0x2a, 0xab, 0x50, 0xa5, 0xb6, 0x12, 0xb8, 0x30, 0x85, 0x9b, 0xbc, 0x09, - 0x17, 0xf8, 0x72, 0x5c, 0xf7, 0xef, 0x79, 0xeb, 0xb4, 0xed, 0x1c, 0xaa, 0x0f, 0x98, 0xe6, 0x1f, - 0xf0, 0xe4, 0xf1, 0x51, 0xf9, 0x42, 0x3d, 0xab, 0x02, 0x66, 0xb7, 0x23, 0x0e, 0x3c, 0x95, 0x04, - 0x20, 0x3d, 0x70, 0x43, 0xd7, 0xf7, 0x84, 0x39, 0x66, 0x26, 0x36, 0xc7, 0xd4, 0x07, 0x57, 0xc3, - 0x93, 0x70, 0x90, 0x7f, 0x68, 0xc1, 0xf9, 0xac, 0x65, 0xb8, 0x54, 0xca, 0xe3, 0xa2, 0x2d, 0xb5, - 0xb4, 0xc4, 0x8c, 0xc8, 0x14, 0x0a, 0x99, 0x4c, 0x90, 0xf7, 0x2c, 0x98, 0x73, 0x8c, 0xa3, 0xe4, - 0x12, 0x70, 0xae, 0x6e, 0x8c, 0x6b, 0xd0, 0x88, 0x31, 0x56, 0x17, 0x8f, 0x8f, 0xca, 0x89, 0xe3, - 0x2a, 0x26, 0x28, 0x92, 0x7f, 0x6c, 0xc1, 0x85, 0xcc, 0x35, 0xbe, 0x34, 0x7b, 0x1a, 0x3d, 0xc4, - 0x27, 0x49, 0xb6, 0xcc, 0xc9, 0x66, 0x83, 0x7c, 0xd3, 0xd2, 0x5b, 0x99, 0xba, 0x7b, 0x59, 0x9a, - 0xe3, 0xac, 0xdd, 0x1a, 0xf3, 0xf4, 0x1c, 0xab, 0x0f, 0x0a, 0x71, 0xf5, 0x9c, 0xb1, 0x33, 0xaa, - 0x42, 0x4c, 0x93, 0x27, 0xdf, 0xb0, 0xd4, 0xd6, 0xa8, 0x39, 0x3a, 0x73, 0x5a, 0x1c, 0x91, 0x78, - 0xa7, 0xd5, 0x0c, 0xa5, 0x88, 0x93, 0x9f, 0x85, 0x65, 0x67, 0xc7, 0x0f, 0xa2, 0xcc, 0xc5, 0xb7, - 0x34, 0xcf, 0x97, 0xd1, 0xe5, 0xe3, 0xa3, 0xf2, 0x72, 0x65, 0x60, 0x2d, 0x3c, 0x01, 0x83, 0xfd, - 0xdb, 0x45, 0x98, 0x13, 0x47, 0x02, 0xb9, 0x75, 0xfd, 0x8e, 0x05, 0x4f, 0x37, 0x7a, 0x41, 0x40, - 0xbd, 0xa8, 0x1e, 0xd1, 0x6e, 0xff, 0xc6, 0x65, 0x9d, 0xea, 0xc6, 0xf5, 0xcc, 0xf1, 0x51, 0xf9, - 0xe9, 0xb5, 0x13, 0xe8, 0xe3, 0x89, 0xdc, 0x91, 0x7f, 0x67, 0x81, 0x2d, 0x2b, 0x54, 0x9d, 0xc6, - 0x7e, 0x2b, 0xf0, 0x7b, 0x5e, 0xb3, 0xff, 0x23, 0x26, 0x4e, 0xf5, 0x23, 0x9e, 0x3b, 0x3e, 0x2a, - 0xdb, 0x6b, 0x0f, 0xe5, 0x02, 0x87, 0xe0, 0x94, 0xbc, 0x0e, 0x67, 0x65, 0xad, 0xab, 0xf7, 0xbb, - 0x34, 0x70, 0x99, 0xf2, 0x2d, 0x15, 0xc7, 0xd8, 0x6d, 0x27, 0x5d, 0x01, 0xfb, 0xdb, 0x90, 0x10, - 0xa6, 0xef, 0x51, 0xb7, 0xb5, 0x17, 0x29, 0xf5, 0x69, 0x4c, 0x5f, 0x1d, 0x69, 0x1e, 0xb8, 0x23, - 0x70, 0x56, 0x67, 0x8f, 0x8f, 0xca, 0xd3, 0xf2, 0x0f, 0x2a, 0x4a, 0xe4, 0x26, 0xcc, 0x8b, 0x03, - 0x5b, 0xcd, 0xf5, 0x5a, 0x35, 0xdf, 0x13, 0x0e, 0x27, 0xa5, 0xea, 0x73, 0x6a, 0xc3, 0xaf, 0x27, - 0xa0, 0x0f, 0x8e, 0xca, 0x73, 0xea, 0xf7, 0xf6, 0x61, 0x97, 0x62, 0xaa, 0xb5, 0xfd, 0xfb, 0x53, - 0x00, 0x6a, 0xba, 0xd2, 0x2e, 0xf9, 0x28, 0x94, 0x42, 0x1a, 0x09, 0xaa, 0xf2, 0x06, 0x41, 0x5c, - 0xcc, 0xa8, 0x42, 0x8c, 0xe1, 0x64, 0x1f, 0x8a, 0x5d, 0xa7, 0x17, 0x52, 0x39, 0xf8, 0x37, 0x72, - 0x19, 0xfc, 0x1a, 0xc3, 0x28, 0x4e, 0x68, 0xfc, 0x27, 0x0a, 0x1a, 0xe4, 0x2b, 0x16, 0x00, 0x4d, - 0x0e, 0xd8, 0xd8, 0x96, 0x12, 0x49, 0x32, 0x1e, 0x53, 0xd6, 0x07, 0xd5, 0xf9, 0xe3, 0xa3, 0x32, - 0x18, 0x43, 0x6f, 0x90, 0x25, 0xf7, 0x60, 0xc6, 0x51, 0x32, 0x7f, 0xf2, 0x34, 0x64, 0x3e, 0x3f, - 0x38, 0xe9, 0x49, 0xab, 0x89, 0x91, 0xaf, 0x59, 0x30, 0x1f, 0xd2, 0x48, 0x0e, 0x15, 0x93, 0x3c, - 0x52, 0xe1, 0x1d, 0x73, 0xd2, 0xd5, 0x13, 0x38, 0x85, 0x04, 0x4d, 0x96, 0x61, 0x8a, 0xae, 0x62, - 0xe5, 0x3a, 0x75, 0x9a, 0x34, 0xe0, 0xe7, 0x72, 0xa9, 0x49, 0x8d, 0xcf, 0x8a, 0x81, 0x53, 0xb3, - 0x62, 0x94, 0x61, 0x8a, 0xae, 0x62, 0x65, 0xcb, 0x0d, 0x02, 0x5f, 0xb2, 0x32, 0x93, 0x13, 0x2b, - 0x06, 0x4e, 0xcd, 0x8a, 0x51, 0x86, 0x29, 0xba, 0xf6, 0xb7, 0xcf, 0xc0, 0xbc, 0x5a, 0x48, 0xb1, - 0x66, 0x2f, 0xcc, 0x40, 0x03, 0x34, 0xfb, 0x35, 0x13, 0x88, 0xc9, 0xba, 0xac, 0xb1, 0x58, 0xaa, - 0x49, 0xc5, 0x5e, 0x37, 0xae, 0x9b, 0x40, 0x4c, 0xd6, 0x25, 0x1d, 0x28, 0x86, 0x11, 0xed, 0xaa, - 0xcb, 0xe0, 0x31, 0xef, 0x2a, 0x63, 0xf9, 0x10, 0x5f, 0xf7, 0xb0, 0x7f, 0x21, 0x0a, 0x2a, 0xdc, - 0x92, 0x19, 0x25, 0x8c, 0x9b, 0x72, 0x71, 0xe4, 0xb3, 0x3e, 0x93, 0x76, 0x53, 0x31, 0x1a, 0xc9, - 0x32, 0x4c, 0x91, 0xcf, 0x50, 0xf6, 0x8b, 0xa7, 0xa8, 0xec, 0x7f, 0x16, 0x66, 0x3a, 0xce, 0xfd, - 0x7a, 0x2f, 0x68, 0x3d, 0xfa, 0xa1, 0x42, 0xba, 0xd7, 0x09, 0x2c, 0xa8, 0xf1, 0x91, 0x2f, 0x5b, - 0x86, 0xc8, 0x99, 0xe6, 0xc8, 0xef, 0xe4, 0x2b, 0x72, 0xf4, 0x5e, 0x39, 0x50, 0xf8, 0xf4, 0xa9, - 0xde, 0x33, 0x8f, 0x5d, 0xf5, 0x66, 0x6a, 0xa4, 0x58, 0x20, 0x5a, 0x8d, 0x2c, 0x9d, 0xaa, 0x1a, - 0xb9, 0x96, 0x20, 0x86, 0x29, 0xe2, 0x9c, 0x1f, 0xb1, 0xe6, 0x34, 0x3f, 0x70, 0xaa, 0xfc, 0xd4, - 0x13, 0xc4, 0x30, 0x45, 0x7c, 0xf0, 0x79, 0x73, 0xf6, 0x74, 0xce, 0x9b, 0x73, 0x39, 0x9c, 0x37, - 0x4f, 0x56, 0xc5, 0xcf, 0x8c, 0xab, 0x8a, 0x93, 0x1b, 0x40, 0x9a, 0x87, 0x9e, 0xd3, 0x71, 0x1b, - 0x52, 0x58, 0xf2, 0x6d, 0x73, 0x9e, 0xdb, 0x23, 0x96, 0xa5, 0x20, 0x23, 0xeb, 0x7d, 0x35, 0x30, - 0xa3, 0x15, 0x89, 0x60, 0xa6, 0xab, 0x34, 0xae, 0x85, 0x3c, 0x66, 0xbf, 0xd2, 0xc0, 0x84, 0xbf, - 0x00, 0x5b, 0x78, 0xaa, 0x04, 0x35, 0x25, 0xb2, 0x09, 0xe7, 0x3b, 0xae, 0x57, 0xf3, 0x9b, 0x61, - 0x8d, 0x06, 0xd2, 0xda, 0x52, 0xa7, 0xd1, 0xd2, 0x22, 0xef, 0x1b, 0x7e, 0x82, 0xde, 0xca, 0x80, - 0x63, 0x66, 0x2b, 0xfb, 0x7f, 0x5a, 0xb0, 0xb8, 0xd6, 0xf6, 0x7b, 0xcd, 0x3b, 0x4e, 0xd4, 0xd8, - 0x13, 0x57, 0xe5, 0xe4, 0x35, 0x98, 0x71, 0xbd, 0x88, 0x06, 0x07, 0x4e, 0x5b, 0xee, 0x4f, 0xb6, - 0x32, 0x9f, 0x6e, 0xc8, 0xf2, 0x07, 0x47, 0xe5, 0xf9, 0xf5, 0x5e, 0xc0, 0xdd, 0xe9, 0x84, 0xb4, - 0x42, 0xdd, 0x86, 0x7c, 0xdb, 0x82, 0xb3, 0xe2, 0xb2, 0x7d, 0xdd, 0x89, 0x9c, 0x5b, 0x3d, 0x1a, - 0xb8, 0x54, 0x5d, 0xb7, 0x8f, 0x29, 0xa8, 0xd2, 0xbc, 0x2a, 0x02, 0x87, 0xb1, 0xa2, 0xbe, 0x95, - 0xa6, 0x8c, 0xfd, 0xcc, 0xd8, 0xbf, 0x52, 0x80, 0x27, 0x07, 0xe2, 0x22, 0xcb, 0x30, 0xe1, 0x36, - 0xe5, 0xa7, 0x83, 0xc4, 0x3b, 0xb1, 0xd1, 0xc4, 0x09, 0xb7, 0x49, 0x56, 0xb8, 0xce, 0x19, 0xd0, - 0x30, 0x54, 0x37, 0xaf, 0x25, 0xad, 0x1e, 0xca, 0x52, 0x34, 0x6a, 0x90, 0x32, 0x14, 0xb9, 0x6b, - 0xa5, 0x3c, 0x4f, 0x70, 0x2d, 0x96, 0x7b, 0x31, 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, 0xaf, 0x64, 0x6a, 0x1c, 0x07, - 0x4a, 0x5c, 0xac, 0xaf, 0x02, 0x1a, 0xf5, 0x02, 0x8f, 0x75, 0x2d, 0xdf, 0x06, 0x67, 0x04, 0x17, - 0xa8, 0x4b, 0xd1, 0xa8, 0x61, 0xff, 0xcb, 0x09, 0x38, 0x9f, 0xc5, 0x3a, 0xdb, 0x6d, 0xa6, 0x04, - 0xb7, 0xf2, 0x68, 0xfc, 0x99, 0xfc, 0xfb, 0x47, 0xfa, 0x8d, 0x68, 0xef, 0x0a, 0xe9, 0xd9, 0x26, - 0xe9, 0x92, 0xcf, 0xe8, 0x1e, 0x9a, 0x78, 0xc4, 0x1e, 0xd2, 0x98, 0x53, 0xbd, 0xf4, 0x0c, 0x4c, - 0x86, 0x6c, 0xe4, 0x0b, 0xc9, 0xeb, 0x0e, 0x3e, 0x46, 0x1c, 0xc2, 0x6a, 0xf4, 0x3c, 0x37, 0x92, - 0xf1, 0x08, 0xba, 0xc6, 0x6d, 0xcf, 0x8d, 0x90, 0x43, 0xec, 0x6f, 0x4d, 0xc0, 0xf2, 0xe0, 0x8f, - 0x22, 0xdf, 0xb2, 0x00, 0x9a, 0xec, 0xb8, 0x12, 0x72, 0xa7, 0x5e, 0xe1, 0x67, 0xe3, 0x9c, 0x56, - 0x1f, 0xae, 0x2b, 0x4a, 0xb1, 0xd3, 0x95, 0x2e, 0x0a, 0xd1, 0x60, 0x84, 0xbc, 0xa0, 0xa6, 0x3e, - 0xbf, 0xaa, 0x11, 0x8b, 0x49, 0xb7, 0xd9, 0xd2, 0x10, 0x34, 0x6a, 0xb1, 0xf3, 0xa8, 0xe7, 0x74, - 0x68, 0xd8, 0x75, 0x74, 0x74, 0x07, 0x3f, 0x8f, 0xde, 0x54, 0x85, 0x18, 0xc3, 0xed, 0x36, 0x3c, - 0x3b, 0x04, 0x9f, 0x39, 0x39, 0xcf, 0xdb, 0xff, 0xc3, 0x82, 0x8b, 0x6b, 0xed, 0x5e, 0x18, 0xd1, - 0xe0, 0xff, 0x1b, 0x1f, 0xb6, 0xff, 0x65, 0xc1, 0x53, 0x03, 0xbe, 0xf9, 0x31, 0xb8, 0xb2, 0xbd, - 0x93, 0x74, 0x65, 0xbb, 0x3d, 0xee, 0x94, 0xce, 0xfc, 0x8e, 0x01, 0x1e, 0x6d, 0xbf, 0x69, 0xc1, - 0x19, 0x26, 0xb6, 0x9a, 0x7e, 0x2b, 0xa7, 0x8d, 0xf3, 0x59, 0x28, 0xfe, 0x3c, 0xdb, 0x80, 0xd2, - 0x93, 0x8c, 0xef, 0x4a, 0x28, 0x60, 0x6c, 0xcd, 0x38, 0x5d, 0xf7, 0x2d, 0x1a, 0xf0, 0x0d, 0xa8, - 0x90, 0x5c, 0x33, 0x15, 0x0d, 0x41, 0xa3, 0x96, 0xfd, 0x69, 0x90, 0xce, 0x62, 0xa9, 0x15, 0x67, - 0x0d, 0xb3, 0xe2, 0xec, 0xff, 0x30, 0x01, 0x86, 0xf1, 0xe3, 0x31, 0xcc, 0x64, 0x2f, 0x31, 0x93, - 0xc7, 0x3c, 0xb8, 0x1b, 0xa6, 0x9c, 0x41, 0xc1, 0x3c, 0x07, 0xa9, 0x60, 0x9e, 0x9b, 0xb9, 0x51, - 0x3c, 0x39, 0x96, 0xe7, 0x07, 0x16, 0x3c, 0x15, 0x57, 0xee, 0xb7, 0x4b, 0x3e, 0x5c, 0x2c, 0xbd, - 0x0c, 0xb3, 0x4e, 0xdc, 0x4c, 0xce, 0x1b, 0x23, 0x92, 0x42, 0x83, 0xd0, 0xac, 0x17, 0xfb, 0xa0, - 0x17, 0x1e, 0xd1, 0x07, 0x7d, 0xf2, 0x64, 0x1f, 0x74, 0xfb, 0xcf, 0x27, 0xe0, 0x52, 0xff, 0x97, - 0xa9, 0x05, 0x35, 0xdc, 0x25, 0xff, 0x2b, 0x30, 0x17, 0xc9, 0x06, 0xc6, 0xf6, 0xa0, 0xa3, 0x3a, - 0xb7, 0x0d, 0x18, 0x26, 0x6a, 0xb2, 0x96, 0x0d, 0xb1, 0x94, 0xeb, 0x0d, 0xbf, 0xab, 0x22, 0x18, - 0x74, 0xcb, 0x35, 0x03, 0x86, 0x89, 0x9a, 0xda, 0x37, 0x74, 0xf2, 0xd4, 0x7d, 0x43, 0xeb, 0x70, - 0x41, 0x79, 0xc3, 0x5d, 0xf3, 0x83, 0x35, 0xbf, 0xd3, 0x6d, 0x53, 0x19, 0xc3, 0xc0, 0x98, 0xbd, - 0x24, 0x9b, 0x5c, 0xc0, 0xac, 0x4a, 0x98, 0xdd, 0xd6, 0xfe, 0x41, 0x01, 0xce, 0xc5, 0xdd, 0xbe, - 0xe6, 0x7b, 0x4d, 0x97, 0xfb, 0x14, 0xbe, 0x0a, 0x93, 0xd1, 0x61, 0x57, 0x75, 0xf6, 0x5f, 0x55, - 0xec, 0x6c, 0x1f, 0x76, 0xd9, 0x68, 0x5f, 0xcc, 0x68, 0xc2, 0x2d, 0xc3, 0xbc, 0x11, 0xd9, 0xd4, - 0xab, 0x43, 0x8c, 0xc0, 0x4b, 0xc9, 0xd9, 0xfc, 0xe0, 0xa8, 0x9c, 0x11, 0xd4, 0xbc, 0xa2, 0x31, - 0x25, 0xe7, 0x3c, 0xb9, 0x0b, 0xf3, 0x6d, 0x27, 0x8c, 0x6e, 0x77, 0x9b, 0x4e, 0x44, 0xb7, 0x5d, - 0xe9, 0xa1, 0x31, 0x5a, 0x60, 0x80, 0xbe, 0xca, 0xde, 0x4c, 0x60, 0xc2, 0x14, 0x66, 0x72, 0x00, - 0x84, 0x95, 0x6c, 0x07, 0x8e, 0x17, 0x8a, 0xaf, 0x62, 0xf4, 0x46, 0x0f, 0x44, 0xd0, 0x27, 0xc3, - 0xcd, 0x3e, 0x6c, 0x98, 0x41, 0x81, 0x3c, 0x07, 0x53, 0x01, 0x75, 0x42, 0x39, 0x98, 0xa5, 0x78, - 0xfd, 0x23, 0x2f, 0x45, 0x09, 0x35, 0x17, 0xd4, 0xd4, 0x43, 0x16, 0xd4, 0x9f, 0x5a, 0x30, 0x1f, - 0x0f, 0xd3, 0x63, 0xd8, 0x59, 0x3b, 0xc9, 0x9d, 0xf5, 0x7a, 0x5e, 0x22, 0x71, 0xc0, 0x66, 0xfa, - 0x07, 0x53, 0xe6, 0xf7, 0x71, 0xc7, 0xf0, 0x2f, 0x42, 0x49, 0xad, 0x6a, 0xa5, 0xb2, 0x8e, 0x79, - 0xc0, 0x4e, 0x28, 0x33, 0x46, 0x40, 0x93, 0x24, 0x82, 0x31, 0x3d, 0xb6, 0x95, 0x37, 0xe5, 0x36, - 0x2d, 0xa7, 0xbd, 0xde, 0xca, 0xd5, 0xf6, 0x9d, 0xb5, 0x95, 0xab, 0x36, 0xe4, 0x36, 0x5c, 0xec, - 0x06, 0x3e, 0x0f, 0xab, 0x5d, 0xa7, 0x4e, 0xb3, 0xed, 0x7a, 0x54, 0x59, 0x31, 0x84, 0x27, 0xc5, - 0x53, 0xc7, 0x47, 0xe5, 0x8b, 0xb5, 0xec, 0x2a, 0x38, 0xa8, 0x6d, 0x32, 0x30, 0x6b, 0x72, 0x88, - 0xc0, 0xac, 0xbf, 0xa3, 0x6d, 0x85, 0x34, 0x94, 0xe1, 0x51, 0x9f, 0xcb, 0x6b, 0x28, 0x33, 0xc4, - 0x7a, 0x3c, 0xa5, 0x2a, 0x92, 0x28, 0x6a, 0xf2, 0x83, 0x0d, 0x52, 0x53, 0x8f, 0x68, 0x90, 0x8a, - 0xfd, 0xeb, 0xa7, 0x7f, 0x92, 0xfe, 0xf5, 0x33, 0x1f, 0x28, 0xff, 0xfa, 0xf7, 0x8b, 0xb0, 0x98, - 0xd6, 0x40, 0x4e, 0x3f, 0xe8, 0xec, 0xef, 0x59, 0xb0, 0xa8, 0x56, 0x8f, 0xa0, 0x49, 0xd5, 0x55, - 0xc3, 0x66, 0x4e, 0x8b, 0x56, 0xe8, 0x52, 0x3a, 0x1a, 0x7f, 0x3b, 0x45, 0x0d, 0xfb, 0xe8, 0x93, - 0xb7, 0x61, 0x56, 0x5b, 0xe4, 0x1f, 0x29, 0x02, 0x6d, 0x81, 0x6b, 0x51, 0x31, 0x0a, 0x34, 0xf1, - 0x91, 0xf7, 0x2d, 0x80, 0x86, 0xda, 0xe6, 0xd4, 0xea, 0xba, 0x95, 0xd7, 0xea, 0xd2, 0x1b, 0x68, - 0xac, 0x2c, 0xeb, 0xa2, 0x10, 0x0d, 0xc2, 0xe4, 0x57, 0xb8, 0x2d, 0x5e, 0x6b, 0x77, 0x22, 0xca, - 0x7f, 0x6c, 0xdf, 0xe1, 0x13, 0x14, 0xd3, 0x58, 0x95, 0x32, 0x40, 0x21, 0x26, 0x98, 0xb0, 0x5f, - 0x05, 0xed, 0xed, 0xc9, 0xc4, 0x16, 0xf7, 0xf7, 0xac, 0x39, 0xd1, 0x9e, 0x9c, 0x82, 0x5a, 0x6c, - 0x5d, 0x53, 0x00, 0x8c, 0xeb, 0xd8, 0x5f, 0x80, 0xf9, 0xd7, 0x03, 0xa7, 0xbb, 0xe7, 0x72, 0x9b, - 0x37, 0x3b, 0x5b, 0x7d, 0x04, 0xa6, 0x9d, 0x66, 0x33, 0x2b, 0x71, 0x44, 0x45, 0x14, 0xa3, 0x82, - 0x0f, 0x75, 0x8c, 0xb2, 0x7f, 0xdf, 0x02, 0x12, 0xdf, 0x1b, 0xba, 0x5e, 0x6b, 0xcb, 0x89, 0x1a, - 0x7b, 0xec, 0x7c, 0xb4, 0xc7, 0x4b, 0xb3, 0xce, 0x47, 0xd7, 0x35, 0x04, 0x8d, 0x5a, 0xe4, 0x5d, - 0x98, 0x15, 0xff, 0xde, 0xd2, 0x16, 0x82, 0xb1, 0x23, 0x08, 0xc4, 0x86, 0xc2, 0x79, 0x12, 0xb3, - 0xf0, 0x7a, 0x4c, 0x01, 0x4d, 0x72, 0xac, 0xab, 0x36, 0xbc, 0xdd, 0x76, 0xef, 0x7e, 0x73, 0x27, - 0xee, 0xaa, 0x6e, 0xe0, 0xef, 0xba, 0x6d, 0x9a, 0xee, 0xaa, 0x9a, 0x28, 0x46, 0x05, 0x1f, 0xae, - 0xab, 0xfe, 0x8d, 0x05, 0xe7, 0x37, 0xc2, 0xc8, 0xf5, 0xd7, 0x69, 0x18, 0xb1, 0x6d, 0x85, 0x09, - 0x9f, 0x5e, 0x7b, 0x18, 0xc7, 0xed, 0x75, 0x58, 0x94, 0x77, 0x98, 0xbd, 0x9d, 0x90, 0x46, 0x86, - 0x1e, 0xaf, 0xd7, 0xf1, 0x5a, 0x0a, 0x8e, 0x7d, 0x2d, 0x18, 0x16, 0x79, 0x99, 0x19, 0x63, 0x29, - 0x24, 0xb1, 0xd4, 0x53, 0x70, 0xec, 0x6b, 0x61, 0x7f, 0xbf, 0x00, 0xe7, 0xf8, 0x67, 0xa4, 0x82, - 0x2e, 0xbe, 0x31, 0x28, 0xe8, 0x62, 0xcc, 0xa5, 0xcc, 0x69, 0x3d, 0x42, 0xc8, 0xc5, 0xdf, 0xb5, - 0x60, 0xa1, 0x99, 0xec, 0xe9, 0x7c, 0x6c, 0x3a, 0x59, 0x63, 0x28, 0x5c, 0xb6, 0x52, 0x85, 0x98, - 0xa6, 0x4f, 0x7e, 0xd5, 0x82, 0x85, 0x24, 0x9b, 0x4a, 0xba, 0x9f, 0x42, 0x27, 0x69, 0x1f, 0xeb, - 0x64, 0x79, 0x88, 0x69, 0x16, 0xec, 0x3f, 0x9c, 0x90, 0x43, 0x7a, 0x1a, 0x11, 0x05, 0xe4, 0x1e, - 0x94, 0xa2, 0x76, 0x28, 0x0a, 0xe5, 0xd7, 0x8e, 0x79, 0x22, 0xdc, 0xde, 0xac, 0x0b, 0xf7, 0x81, - 0x58, 0x69, 0x93, 0x25, 0x4c, 0xf9, 0x54, 0xb4, 0x38, 0xe1, 0x46, 0x57, 0x12, 0xce, 0xe5, 0x28, - 0xba, 0xbd, 0x56, 0x4b, 0x13, 0x96, 0x25, 0x8c, 0xb0, 0xa2, 0x65, 0xff, 0x96, 0x05, 0xa5, 0x1b, - 0xbe, 0x92, 0x23, 0x3f, 0x9b, 0x83, 0xa1, 0x47, 0xeb, 0x83, 0xfa, 0x9a, 0x32, 0x3e, 0x62, 0xbc, - 0x96, 0x30, 0xf3, 0x3c, 0x6d, 0xe0, 0x5e, 0xe1, 0xf9, 0xb3, 0x18, 0xaa, 0x1b, 0xfe, 0xce, 0x40, - 0xd3, 0xe3, 0xaf, 0x15, 0xe1, 0xcc, 0x1b, 0xce, 0x21, 0xf5, 0x22, 0x67, 0xf4, 0x4d, 0xe2, 0x65, - 0x98, 0x75, 0xba, 0xfc, 0x1e, 0xcc, 0xd0, 0xf1, 0x63, 0xcb, 0x49, 0x0c, 0x42, 0xb3, 0x5e, 0x2c, - 0xd0, 0x44, 0x76, 0x9d, 0x2c, 0x51, 0xb4, 0x96, 0x82, 0x63, 0x5f, 0x0b, 0x72, 0x03, 0x88, 0x8c, - 0x46, 0xad, 0x34, 0x1a, 0x7e, 0xcf, 0x13, 0x22, 0x4d, 0x18, 0x55, 0xf4, 0x61, 0x73, 0xab, 0xaf, - 0x06, 0x66, 0xb4, 0x22, 0x9f, 0x87, 0xa5, 0x06, 0xc7, 0x2c, 0x8f, 0x1e, 0x26, 0x46, 0x71, 0xfc, - 0xd4, 0x71, 0x02, 0x6b, 0x03, 0xea, 0xe1, 0x40, 0x0c, 0x8c, 0xd3, 0x30, 0xf2, 0x03, 0xa7, 0x45, - 0x4d, 0xbc, 0x53, 0x49, 0x4e, 0xeb, 0x7d, 0x35, 0x30, 0xa3, 0x15, 0xf9, 0x12, 0x94, 0xa2, 0xbd, - 0x80, 0x86, 0x7b, 0x7e, 0xbb, 0x29, 0xfd, 0x16, 0xc6, 0xb4, 0xb4, 0xc9, 0xd1, 0xdf, 0x56, 0x58, - 0x8d, 0xe9, 0xad, 0x8a, 0x30, 0xa6, 0x49, 0x02, 0x98, 0x0a, 0x1b, 0x7e, 0x97, 0x86, 0x52, 0x65, - 0xbf, 0x91, 0x0b, 0x75, 0x6e, 0x39, 0x32, 0x6c, 0x7c, 0x9c, 0x02, 0x4a, 0x4a, 0xf6, 0xef, 0x4d, - 0xc0, 0x9c, 0x59, 0x71, 0x08, 0xd9, 0xf4, 0x15, 0x0b, 0xe6, 0x1a, 0xbe, 0x17, 0x05, 0x7e, 0x5b, - 0xd8, 0xaf, 0xf2, 0xd1, 0x28, 0x18, 0xaa, 0x75, 0x1a, 0x39, 0x6e, 0xdb, 0x30, 0x85, 0x19, 0x64, - 0x30, 0x41, 0x94, 0x7c, 0xdd, 0x82, 0x85, 0xd8, 0xcd, 0x2d, 0x36, 0xa4, 0xe5, 0xca, 0x88, 0x16, - 0xf5, 0x57, 0x93, 0x94, 0x30, 0x4d, 0xda, 0xde, 0x81, 0xc5, 0xf4, 0x68, 0xb3, 0xae, 0xec, 0x3a, - 0x72, 0xad, 0x17, 0xe2, 0xae, 0xac, 0x39, 0x61, 0x88, 0x1c, 0x42, 0x9e, 0x87, 0x99, 0x8e, 0x13, - 0xb4, 0x5c, 0xcf, 0x69, 0xf3, 0x5e, 0x2c, 0x18, 0x02, 0x49, 0x96, 0xa3, 0xae, 0x61, 0x7f, 0x1c, - 0xe6, 0xb6, 0x1c, 0xaf, 0x45, 0x9b, 0x52, 0x0e, 0x3f, 0x3c, 0xa6, 0xed, 0x47, 0x93, 0x30, 0x6b, - 0x9c, 0xcd, 0x4e, 0xff, 0x9c, 0x95, 0x48, 0xa9, 0x51, 0xc8, 0x31, 0xa5, 0xc6, 0x67, 0x01, 0x76, - 0x5d, 0xcf, 0x0d, 0xf7, 0x1e, 0x31, 0x59, 0x07, 0xbf, 0xd7, 0xbd, 0xa6, 0x31, 0xa0, 0x81, 0x2d, - 0xbe, 0x3c, 0x2b, 0x9e, 0x90, 0x79, 0xea, 0x7d, 0xcb, 0xd8, 0x6e, 0xa6, 0xf2, 0x70, 0x16, 0x30, - 0x06, 0x66, 0x45, 0x6d, 0x3f, 0x22, 0xd7, 0xd0, 0x49, 0xbb, 0xd2, 0x36, 0xcc, 0x04, 0x34, 0xec, - 0x75, 0xd8, 0x89, 0x71, 0x7a, 0xe4, 0x6e, 0xe0, 0x6e, 0x1b, 0x28, 0xdb, 0xa3, 0xc6, 0xb4, 0xfc, - 0x2a, 0x9c, 0x49, 0xb0, 0x30, 0x52, 0xf6, 0x21, 0x1f, 0x32, 0x0d, 0x00, 0x8f, 0x72, 0x99, 0xc3, - 0xc6, 0xa2, 0x6d, 0x64, 0xeb, 0xd0, 0x63, 0x21, 0x9c, 0x73, 0x04, 0xcc, 0xfe, 0xf3, 0x29, 0x90, - 0xf7, 0xdf, 0x43, 0x88, 0x2b, 0xf3, 0xd6, 0x6b, 0xe2, 0x11, 0x6e, 0xbd, 0x6e, 0xc0, 0x9c, 0xeb, - 0xb9, 0x91, 0xeb, 0xb4, 0xb9, 0x71, 0x47, 0x6e, 0xa7, 0xca, 0x7b, 0x79, 0x6e, 0xc3, 0x80, 0x65, - 0xe0, 0x49, 0xb4, 0x25, 0xb7, 0xa0, 0xc8, 0xf7, 0x1b, 0x39, 0x81, 0x47, 0xbf, 0xa4, 0xe7, 0xfe, - 0x19, 0x22, 0xa4, 0x49, 0x60, 0xe2, 0x87, 0x0f, 0x91, 0xae, 0x44, 0x1f, 0xbf, 0xe5, 0x3c, 0x8e, - 0x0f, 0x1f, 0x29, 0x38, 0xf6, 0xb5, 0x60, 0x58, 0x76, 0x1d, 0xb7, 0xdd, 0x0b, 0x68, 0x8c, 0x65, - 0x2a, 0x89, 0xe5, 0x5a, 0x0a, 0x8e, 0x7d, 0x2d, 0xc8, 0x2e, 0xcc, 0xc9, 0x32, 0xe1, 0x72, 0x35, - 0xfd, 0x88, 0x5f, 0xc9, 0x5d, 0xeb, 0xae, 0x19, 0x98, 0x30, 0x81, 0x97, 0xf4, 0xe0, 0xac, 0xeb, - 0x35, 0x7c, 0xaf, 0xd1, 0xee, 0x85, 0xee, 0x01, 0x8d, 0xe3, 0x89, 0x1e, 0x85, 0xd8, 0x85, 0xe3, - 0xa3, 0xf2, 0xd9, 0x8d, 0x34, 0x3a, 0xec, 0xa7, 0x40, 0xbe, 0x6c, 0xc1, 0x85, 0x86, 0xef, 0x85, - 0x3c, 0xfe, 0xff, 0x80, 0x5e, 0x0d, 0x02, 0x3f, 0x10, 0xb4, 0x4b, 0x8f, 0x48, 0x9b, 0xdb, 0x14, - 0xd7, 0xb2, 0x50, 0x62, 0x36, 0x25, 0xf2, 0x0e, 0xcc, 0x74, 0x03, 0xff, 0xc0, 0x6d, 0xd2, 0x40, - 0xba, 0xef, 0x6d, 0xe6, 0x91, 0x8f, 0xa4, 0x26, 0x71, 0xc6, 0xa2, 0x47, 0x95, 0xa0, 0xa6, 0x67, - 0xff, 0xef, 0x59, 0x98, 0x4f, 0x56, 0x27, 0xbf, 0x00, 0xd0, 0x0d, 0xfc, 0x0e, 0x8d, 0xf6, 0xa8, - 0x8e, 0x0b, 0xb9, 0x39, 0x6e, 0xda, 0x0b, 0x85, 0x4f, 0xb9, 0xbc, 0x30, 0x71, 0x11, 0x97, 0xa2, - 0x41, 0x91, 0x04, 0x30, 0xbd, 0x2f, 0xb6, 0x5d, 0xa9, 0x85, 0xbc, 0x91, 0x8b, 0xce, 0x24, 0x29, - 0xf3, 0x80, 0x06, 0x59, 0x84, 0x8a, 0x10, 0xd9, 0x81, 0xc2, 0x3d, 0xba, 0x93, 0x4f, 0xcc, 0xf5, - 0x1d, 0x2a, 0x4f, 0x33, 0xd5, 0xe9, 0xe3, 0xa3, 0x72, 0xe1, 0x0e, 0xdd, 0x41, 0x86, 0x9c, 0x7d, - 0x57, 0x53, 0xdc, 0xdd, 0x4b, 0x51, 0x31, 0xe6, 0x77, 0x25, 0x1c, 0x01, 0xc4, 0x77, 0xc9, 0x22, - 0x54, 0x84, 0xc8, 0x3b, 0x50, 0xba, 0xe7, 0x1c, 0xd0, 0xdd, 0xc0, 0xf7, 0x22, 0xe9, 0x67, 0x35, - 0x66, 0xa8, 0xc0, 0x1d, 0x85, 0x4e, 0xd2, 0xe5, 0xdb, 0xbb, 0x2e, 0xc4, 0x98, 0x1c, 0x39, 0x80, - 0x19, 0x8f, 0xde, 0x43, 0xda, 0x76, 0x1b, 0xf9, 0xb8, 0xe6, 0xdf, 0x94, 0xd8, 0x24, 0x65, 0xbe, - 0xef, 0xa9, 0x32, 0xd4, 0xb4, 0xd8, 0x58, 0xde, 0xf5, 0x77, 0xa4, 0xa0, 0x1a, 0x73, 0x2c, 0xf5, - 0xc9, 0x54, 0x8c, 0xe5, 0x0d, 0x7f, 0x07, 0x19, 0x72, 0xb6, 0x46, 0x1a, 0xda, 0xc9, 0x47, 0x8a, - 0xa9, 0x9b, 0xf9, 0x3a, 0x37, 0x89, 0x35, 0x12, 0x97, 0xa2, 0x41, 0x91, 0xf5, 0x6d, 0x4b, 0x1a, - 0x2b, 0xa5, 0xa0, 0x1a, 0xb3, 0x6f, 0x93, 0xa6, 0x4f, 0xd1, 0xb7, 0xaa, 0x0c, 0x35, 0x2d, 0x46, - 0xd7, 0x95, 0x96, 0xbf, 0x7c, 0x44, 0x55, 0xd2, 0x8e, 0x28, 0xe8, 0xaa, 0x32, 0xd4, 0xb4, 0x58, - 0x7f, 0x87, 0xfb, 0x87, 0xf7, 0x9c, 0xf6, 0xbe, 0xeb, 0xb5, 0x64, 0x9c, 0xe3, 0xb8, 0xd9, 0x6d, - 0xf7, 0x0f, 0xef, 0x08, 0x7c, 0x66, 0x7f, 0xc7, 0xa5, 0x68, 0x50, 0x24, 0xff, 0xc8, 0x82, 0xa9, - 0x6e, 0xbb, 0xd7, 0x72, 0xbd, 0xa5, 0x39, 0xae, 0x27, 0x7e, 0x26, 0x4f, 0x09, 0xbd, 0x52, 0xe3, - 0xa8, 0x85, 0xa2, 0xf8, 0xd3, 0xda, 0x67, 0x8f, 0x17, 0xfe, 0xd2, 0x9f, 0x95, 0x97, 0xa8, 0xd7, - 0xf0, 0x9b, 0xae, 0xd7, 0x5a, 0xbd, 0x1b, 0xfa, 0xde, 0x0a, 0x3a, 0xf7, 0x94, 0x8e, 0x2e, 0x79, - 0x5a, 0xfe, 0x24, 0xcc, 0x1a, 0x28, 0x1e, 0xa6, 0xe8, 0xcd, 0x99, 0x8a, 0xde, 0x6f, 0x4d, 0xc1, - 0x9c, 0x99, 0x51, 0x6f, 0x08, 0xed, 0x4b, 0x9f, 0x38, 0x26, 0x46, 0x39, 0x71, 0xb0, 0x23, 0xa6, - 0x71, 0x7b, 0xa4, 0xcc, 0x5b, 0x1b, 0xb9, 0x29, 0xdc, 0xf1, 0x11, 0xd3, 0x28, 0x0c, 0x31, 0x41, - 0x74, 0x04, 0x87, 0x12, 0xa6, 0xb6, 0x0a, 0xc5, 0xae, 0x98, 0x54, 0x5b, 0x13, 0xaa, 0xda, 0x0b, - 0x00, 0x71, 0x66, 0x39, 0x79, 0xab, 0xa8, 0xf5, 0x61, 0x23, 0xe3, 0x9d, 0x51, 0x8b, 0x3c, 0x07, - 0x53, 0x4c, 0xf5, 0xa1, 0x4d, 0x19, 0x86, 0xad, 0xcf, 0xf1, 0xd7, 0x78, 0x29, 0x4a, 0x28, 0x79, - 0x85, 0x69, 0xa9, 0xb1, 0xc2, 0x22, 0xa3, 0xab, 0xcf, 0xc7, 0x5a, 0x6a, 0x0c, 0xc3, 0x44, 0x4d, - 0xc6, 0x3a, 0x65, 0xfa, 0x05, 0x97, 0x0d, 0x06, 0xeb, 0x5c, 0xe9, 0x40, 0x01, 0xe3, 0x76, 0xa5, - 0x94, 0x3e, 0xc2, 0xd7, 0x74, 0xd1, 0xb0, 0x2b, 0xa5, 0xe0, 0xd8, 0xd7, 0x82, 0x7d, 0x8c, 0xbc, - 0x10, 0x9d, 0x15, 0xce, 0xb6, 0x03, 0xae, 0x32, 0xbf, 0x6a, 0x9e, 0xb5, 0x72, 0x5c, 0x43, 0x62, - 0xd6, 0x0e, 0x7f, 0xd8, 0x1a, 0xef, 0x58, 0xf4, 0x05, 0x98, 0x4f, 0xee, 0x42, 0xb9, 0xdf, 0x7c, - 0x7c, 0x6d, 0x12, 0xce, 0xdd, 0x6c, 0xb9, 0x5e, 0x3a, 0x5b, 0x54, 0x56, 0xb2, 0x70, 0x6b, 0xe4, - 0x64, 0xe1, 0x3a, 0x9e, 0x4b, 0xa6, 0xe2, 0xce, 0x8e, 0xe7, 0x52, 0x79, 0xd1, 0x93, 0x75, 0xc9, - 0x9f, 0x5a, 0xf0, 0xb4, 0xd3, 0x14, 0xe7, 0x02, 0xa7, 0x2d, 0x4b, 0x8d, 0x1c, 0xb7, 0x72, 0x45, - 0x87, 0x63, 0xee, 0xf2, 0xfd, 0x1f, 0xbf, 0x52, 0x39, 0x81, 0xaa, 0x18, 0xf1, 0x9f, 0x92, 0x5f, - 0xf0, 0xf4, 0x49, 0x55, 0xf1, 0x44, 0xf6, 0xc9, 0xdf, 0x80, 0x85, 0xc4, 0x07, 0x4b, 0x4b, 0x78, - 0x49, 0x5c, 0x58, 0xd4, 0x93, 0x20, 0x4c, 0xd7, 0x5d, 0x7e, 0x13, 0x3e, 0xfc, 0x50, 0x3e, 0x47, - 0x9a, 0x6c, 0x5f, 0xb1, 0xa0, 0x24, 0xec, 0xda, 0x48, 0x77, 0x53, 0x4e, 0x98, 0xa9, 0x93, 0x77, - 0xa5, 0xb6, 0x91, 0xe1, 0x84, 0xc9, 0x64, 0xf9, 0xbe, 0xeb, 0x35, 0xe5, 0x28, 0x6b, 0x59, 0xfe, - 0x86, 0xeb, 0x35, 0x91, 0x43, 0xb4, 0xb4, 0x2f, 0x0c, 0xb4, 0x37, 0xfd, 0xba, 0x05, 0xf3, 0x3c, - 0x06, 0x36, 0x3e, 0x13, 0xbe, 0xac, 0x9d, 0x8d, 0x04, 0x1b, 0x97, 0x92, 0xce, 0x46, 0x0f, 0x8e, - 0xca, 0xb3, 0x22, 0x6a, 0x36, 0xe9, 0x7b, 0xf4, 0x39, 0x69, 0x48, 0xe2, 0x2e, 0x51, 0x13, 0x23, - 0xdb, 0x39, 0xb4, 0xa1, 0xb5, 0xae, 0x90, 0x60, 0x8c, 0xcf, 0x7e, 0x17, 0xe6, 0xcc, 0x60, 0x16, - 0xf2, 0x32, 0xcc, 0x76, 0x5d, 0xaf, 0x95, 0x0c, 0x7a, 0xd4, 0xc6, 0xf6, 0x5a, 0x0c, 0x42, 0xb3, - 0x1e, 0x6f, 0xe6, 0xc7, 0xcd, 0x52, 0x36, 0xfa, 0x9a, 0x6f, 0x36, 0x8b, 0xff, 0xf0, 0x1c, 0xdb, - 0x19, 0x41, 0x53, 0xb9, 0xe7, 0xd8, 0xce, 0xa0, 0xf1, 0x93, 0xcb, 0xb1, 0x9d, 0xc5, 0xcc, 0xff, - 0x5d, 0x39, 0xb6, 0x7f, 0x06, 0x46, 0x4d, 0xae, 0xc8, 0xf6, 0xbb, 0x7b, 0x66, 0x60, 0xba, 0xee, - 0x71, 0x19, 0x99, 0x2e, 0xa1, 0xf6, 0x7b, 0x6c, 0xd9, 0xe8, 0x43, 0x6d, 0xa5, 0x17, 0xed, 0x11, - 0x0f, 0x8a, 0xa1, 0xdb, 0x3a, 0x78, 0x29, 0x27, 0x9b, 0x36, 0x43, 0x25, 0x1f, 0x66, 0x88, 0x03, - 0x62, 0x59, 0x21, 0x0a, 0x32, 0xf6, 0x77, 0x0b, 0xb0, 0x98, 0x3e, 0x79, 0xe7, 0xed, 0xd4, 0x40, - 0xbe, 0x6e, 0xc1, 0xbc, 0xd3, 0x8b, 0xf6, 0xa8, 0x17, 0xa9, 0x8b, 0xad, 0x5c, 0xde, 0x0c, 0x49, - 0xf6, 0x9d, 0x91, 0xc2, 0x2a, 0x41, 0x0b, 0x53, 0xb4, 0xc9, 0x5f, 0x81, 0xe9, 0xc8, 0xed, 0x50, - 0xbf, 0x27, 0xec, 0x71, 0x05, 0x71, 0x2e, 0xde, 0x16, 0x45, 0xa8, 0x60, 0xe4, 0x79, 0x76, 0x8e, - 0x61, 0x8a, 0x4c, 0x40, 0xa5, 0xf7, 0xeb, 0x62, 0x6c, 0x40, 0x14, 0xe5, 0xa8, 0x6b, 0x90, 0xfb, - 0x30, 0x2d, 0xdc, 0x1f, 0x94, 0x9f, 0xcb, 0x56, 0x4e, 0x16, 0x02, 0xe1, 0x61, 0x11, 0x0f, 0x81, - 0xf8, 0x1f, 0xa2, 0x22, 0x67, 0x7f, 0x1c, 0x46, 0x4c, 0x78, 0x69, 0x5f, 0x05, 0x82, 0x7e, 0xbb, - 0xbd, 0xe3, 0x34, 0xf6, 0xef, 0xb8, 0x5e, 0xd3, 0xbf, 0xc7, 0xa5, 0xe1, 0x2a, 0x94, 0x02, 0x19, - 0xf5, 0x18, 0xca, 0x89, 0xab, 0xc5, 0xa9, 0x0a, 0x87, 0x0c, 0x31, 0xae, 0x63, 0xff, 0xe1, 0x04, - 0x4c, 0xcb, 0x10, 0xdd, 0xc7, 0xe0, 0x7d, 0xbf, 0x9f, 0xb8, 0x96, 0xdd, 0xc8, 0x25, 0xb2, 0x78, - 0xa0, 0xeb, 0x7d, 0x98, 0x72, 0xbd, 0x7f, 0x23, 0x1f, 0x72, 0x27, 0xfb, 0xdd, 0xff, 0x41, 0x11, - 0x16, 0x52, 0x21, 0xcf, 0x4c, 0x25, 0xee, 0x73, 0x37, 0xbd, 0x9d, 0x6b, 0x54, 0xb5, 0x0e, 0x27, - 0x39, 0xd9, 0xf3, 0x34, 0x4c, 0xa4, 0x27, 0xbe, 0x95, 0xdb, 0xcb, 0x0b, 0x7f, 0x99, 0xa9, 0x78, - 0x44, 0x4f, 0x4a, 0xf2, 0x6d, 0x0b, 0xce, 0x39, 0xfd, 0x4f, 0x57, 0x48, 0xd3, 0xdd, 0xad, 0xdc, - 0xdf, 0xc4, 0xa8, 0x3e, 0x25, 0x99, 0xcc, 0x7a, 0x21, 0x04, 0xb3, 0x58, 0xb1, 0xff, 0xb3, 0x05, - 0x4f, 0x0e, 0x0c, 0xde, 0xe7, 0xb9, 0x9f, 0x82, 0x24, 0x54, 0xca, 0x8c, 0x9c, 0x53, 0x94, 0xe8, - 0x6b, 0xdc, 0x74, 0xba, 0x9e, 0x34, 0x79, 0xf2, 0x12, 0xcc, 0x71, 0x35, 0x91, 0x49, 0xcf, 0x88, - 0x76, 0xe5, 0x2d, 0x14, 0xbf, 0x8f, 0xa8, 0x1b, 0xe5, 0x98, 0xa8, 0x65, 0x7f, 0xdb, 0x82, 0xa5, - 0x41, 0x99, 0x80, 0x86, 0xb0, 0x91, 0xfc, 0xf5, 0x54, 0x04, 0x43, 0xb9, 0x2f, 0x82, 0x21, 0x65, - 0x25, 0x51, 0xc1, 0x0a, 0x86, 0x81, 0xa2, 0xf0, 0x10, 0x07, 0xfd, 0x6f, 0x58, 0x70, 0x71, 0xc0, - 0x82, 0xef, 0x8b, 0x64, 0xb1, 0x1e, 0x39, 0x92, 0x65, 0x62, 0xd8, 0x48, 0x16, 0xfb, 0x8f, 0x0a, - 0xb0, 0x28, 0xf9, 0x89, 0xcf, 0x0a, 0xaf, 0x24, 0xe2, 0x40, 0x7e, 0x2a, 0x15, 0x07, 0x72, 0x3e, - 0x5d, 0xff, 0x2f, 0x83, 0x40, 0x3e, 0x58, 0x41, 0x20, 0x7f, 0x31, 0x01, 0x17, 0x32, 0x13, 0x14, - 0x91, 0xaf, 0x65, 0xec, 0x5e, 0x77, 0x72, 0xce, 0x84, 0x34, 0xe4, 0xfe, 0x35, 0x6e, 0xe4, 0xc4, - 0xaf, 0x9a, 0x11, 0x0b, 0x62, 0x37, 0xda, 0x3d, 0x85, 0x9c, 0x4e, 0x23, 0x06, 0x2f, 0xd8, 0xbf, - 0x54, 0x80, 0x2b, 0xc3, 0x22, 0xfa, 0x80, 0x06, 0xb7, 0x85, 0x89, 0xe0, 0xb6, 0xc7, 0xa4, 0x59, - 0x9c, 0x4a, 0x9c, 0xdb, 0x3f, 0x99, 0xd4, 0xdb, 0x5e, 0xff, 0xfc, 0x1c, 0xca, 0x65, 0x61, 0x9a, - 0x69, 0x9f, 0x2a, 0xc9, 0x71, 0x2c, 0x0a, 0xa7, 0xeb, 0xa2, 0xf8, 0xc1, 0x51, 0xf9, 0x6c, 0x9c, - 0x26, 0x43, 0x16, 0xa2, 0x6a, 0x44, 0xae, 0xc0, 0x4c, 0x20, 0xa0, 0x2a, 0x9c, 0x47, 0xfa, 0x7d, - 0x88, 0x32, 0xd4, 0x50, 0xf2, 0x25, 0x43, 0x5d, 0x9f, 0x3c, 0xad, 0x6c, 0x30, 0x27, 0xb9, 0xb3, - 0xbc, 0x0d, 0x33, 0xa1, 0x4a, 0x40, 0x2c, 0x14, 0x97, 0x17, 0x87, 0x8c, 0x12, 0x73, 0x76, 0x68, - 0x5b, 0x65, 0x23, 0x16, 0xdf, 0xa7, 0x73, 0x15, 0x6b, 0x94, 0xc4, 0xd6, 0x27, 0x70, 0x61, 0x6e, - 0x87, 0xfe, 0xd3, 0x37, 0x89, 0x60, 0x5a, 0x3e, 0xd0, 0x28, 0xef, 0x01, 0xb7, 0x72, 0x8a, 0x08, - 0x91, 0xfe, 0xc2, 0xfc, 0x54, 0xa9, 0x2c, 0x41, 0x8a, 0x94, 0xfd, 0x03, 0x0b, 0x66, 0xe5, 0x1c, - 0x79, 0x0c, 0xe1, 0x72, 0x77, 0x93, 0xe1, 0x72, 0x57, 0x73, 0x91, 0x58, 0x03, 0x62, 0xe5, 0xee, - 0xc2, 0x9c, 0x99, 0x19, 0x8f, 0x7c, 0xd6, 0x90, 0xb8, 0xd6, 0x38, 0xb9, 0xa6, 0x94, 0x4c, 0x8e, - 0xa5, 0xb1, 0xfd, 0xdb, 0x25, 0xdd, 0x8b, 0xfc, 0xec, 0x6a, 0xce, 0x7c, 0xeb, 0xc4, 0x99, 0x6f, - 0x4e, 0xbc, 0x89, 0xfc, 0x27, 0xde, 0x2d, 0x98, 0x51, 0x62, 0x51, 0x2a, 0x0f, 0xcf, 0x9a, 0x0e, - 0xc4, 0x4c, 0x03, 0x61, 0xc8, 0x8c, 0xe5, 0xc2, 0xcf, 0xa0, 0x7a, 0x0c, 0xb5, 0xb8, 0xd6, 0x68, - 0xc8, 0x3b, 0x30, 0x7b, 0xcf, 0x0f, 0xf6, 0xdb, 0xbe, 0xc3, 0xd3, 0x9f, 0x43, 0x1e, 0x77, 0xd6, - 0xda, 0x64, 0x2c, 0xa2, 0x38, 0xee, 0xc4, 0xf8, 0xd1, 0x24, 0x46, 0x2a, 0xb0, 0xd0, 0x71, 0x3d, - 0xa4, 0x4e, 0x53, 0x47, 0xc5, 0x4d, 0x8a, 0x8c, 0xcb, 0x4a, 0xb5, 0xde, 0x4a, 0x82, 0x31, 0x5d, - 0x9f, 0x1b, 0x7f, 0x82, 0x84, 0xb5, 0x41, 0xa6, 0x55, 0xad, 0x8d, 0x3f, 0x19, 0x93, 0x16, 0x0c, - 0x11, 0xc6, 0x90, 0x2c, 0xc7, 0x14, 0x6d, 0xf2, 0x45, 0x98, 0x09, 0x65, 0xda, 0xbb, 0x7c, 0x9c, - 0x1d, 0xf4, 0xd9, 0x5e, 0x20, 0x8d, 0x87, 0x52, 0x95, 0xa0, 0x26, 0x48, 0x36, 0xe1, 0xbc, 0x32, - 0x9f, 0x24, 0x9e, 0xa8, 0x9a, 0x8a, 0xb3, 0x24, 0x61, 0x06, 0x1c, 0x33, 0x5b, 0x31, 0x55, 0x8e, - 0x67, 0x9c, 0x14, 0x77, 0x84, 0xc6, 0xb5, 0x1a, 0x5f, 0x7f, 0x4d, 0x94, 0xd0, 0x93, 0x82, 0x3e, - 0x67, 0xc6, 0x08, 0xfa, 0xac, 0xc3, 0x85, 0x34, 0x88, 0xa7, 0xbf, 0xe2, 0x19, 0xb7, 0x8c, 0x2d, - 0xb4, 0x96, 0x55, 0x09, 0xb3, 0xdb, 0x92, 0x3b, 0x50, 0x0a, 0x28, 0x3f, 0x64, 0x55, 0x94, 0x7b, - 0xd5, 0xc8, 0x8e, 0xa4, 0xa8, 0x10, 0x60, 0x8c, 0x8b, 0x8d, 0xbb, 0x93, 0xcc, 0x81, 0x7c, 0x2b, - 0xc7, 0xb7, 0x51, 0xe5, 0xd8, 0x0f, 0x48, 0x4b, 0x67, 0xff, 0xdb, 0x05, 0x38, 0x93, 0xb0, 0x01, - 0x91, 0x67, 0xa1, 0xc8, 0xf3, 0x81, 0x71, 0x69, 0x35, 0x13, 0x4b, 0x54, 0xd1, 0x39, 0x02, 0x46, - 0x7e, 0xd9, 0x82, 0x85, 0x6e, 0xe2, 0x5a, 0x45, 0x09, 0xf2, 0x71, 0x0d, 0xa7, 0x09, 0xa4, 0xc6, - 0xeb, 0x01, 0x49, 0x62, 0x98, 0xa6, 0xce, 0xe4, 0x81, 0xf4, 0xc6, 0x6e, 0xd3, 0x80, 0xd7, 0x96, - 0x8a, 0x9e, 0x46, 0xb1, 0x96, 0x04, 0x63, 0xba, 0x3e, 0x1b, 0x61, 0xfe, 0x75, 0xe3, 0xbc, 0xbe, - 0x57, 0x51, 0x08, 0x30, 0xc6, 0x45, 0x5e, 0x83, 0x79, 0x99, 0xfa, 0xb6, 0xe6, 0x37, 0xaf, 0x3b, - 0xe1, 0x9e, 0x3c, 0xe1, 0xe8, 0x13, 0xd9, 0x5a, 0x02, 0x8a, 0xa9, 0xda, 0xfc, 0xdb, 0xe2, 0xfc, - 0xc2, 0x1c, 0xc1, 0x54, 0xf2, 0x71, 0x85, 0xb5, 0x24, 0x18, 0xd3, 0xf5, 0xc9, 0xf3, 0xc6, 0x36, - 0x24, 0xee, 0xed, 0xb5, 0x34, 0xc8, 0xd8, 0x8a, 0x2a, 0xb0, 0xd0, 0xe3, 0x07, 0xc2, 0xa6, 0x02, - 0xca, 0xf5, 0xa8, 0x09, 0xde, 0x4e, 0x82, 0x31, 0x5d, 0x9f, 0xbc, 0x0a, 0x67, 0x02, 0x26, 0x6c, - 0x35, 0x02, 0x71, 0x99, 0xaf, 0xef, 0x6a, 0xd1, 0x04, 0x62, 0xb2, 0x2e, 0x79, 0x1d, 0xce, 0xc6, - 0x99, 0x22, 0x15, 0x02, 0x71, 0xbb, 0xaf, 0xd3, 0x96, 0x55, 0xd2, 0x15, 0xb0, 0xbf, 0x0d, 0xf9, - 0x5b, 0xb0, 0x68, 0xf4, 0xc4, 0x86, 0xd7, 0xa4, 0xf7, 0x65, 0x36, 0x3f, 0xfe, 0x6a, 0xce, 0x5a, - 0x0a, 0x86, 0x7d, 0xb5, 0xc9, 0xa7, 0x60, 0xbe, 0xe1, 0xb7, 0xdb, 0x5c, 0xc6, 0x89, 0xc4, 0xfe, - 0x22, 0x6d, 0x9f, 0x48, 0x70, 0x98, 0x80, 0x60, 0xaa, 0x26, 0xb9, 0x01, 0xc4, 0xdf, 0x61, 0xea, - 0x15, 0x6d, 0xbe, 0x2e, 0x9e, 0x77, 0x67, 0x1a, 0xc7, 0x99, 0x64, 0x2c, 0xc8, 0x9b, 0x7d, 0x35, - 0x30, 0xa3, 0x15, 0xcf, 0x7a, 0x66, 0xc4, 0xce, 0xce, 0xe7, 0xf1, 0x12, 0x5d, 0xda, 0x7c, 0xf1, - 0xd0, 0xc0, 0xd9, 0x00, 0xa6, 0x44, 0x68, 0x4e, 0x3e, 0xf9, 0xfb, 0xcc, 0x1c, 0xdf, 0xf1, 0x1e, - 0x21, 0x4a, 0x51, 0x52, 0x22, 0xbf, 0x00, 0xa5, 0x1d, 0xf5, 0xe0, 0x03, 0x4f, 0xda, 0x37, 0xf6, - 0xbe, 0x98, 0x7a, 0xbb, 0x24, 0x3e, 0x9e, 0x6b, 0x00, 0xc6, 0x24, 0xc9, 0x73, 0x30, 0x7b, 0xbd, - 0x56, 0xd1, 0xb3, 0xf0, 0x2c, 0x1f, 0xfd, 0x49, 0xd6, 0x04, 0x4d, 0x00, 0x5b, 0x61, 0x5a, 0x7d, - 0x23, 0xc9, 0x37, 0x54, 0x32, 0xb4, 0x31, 0x56, 0x9b, 0xdf, 0xc0, 0x63, 0x7d, 0xe9, 0x5c, 0xaa, - 0xb6, 0x2c, 0x47, 0x5d, 0x83, 0xbc, 0x0d, 0xb3, 0x72, 0xbf, 0xe0, 0xb2, 0xe9, 0xfc, 0xa3, 0xc5, - 0x65, 0x63, 0x8c, 0x02, 0x4d, 0x7c, 0xfc, 0xda, 0x98, 0xe7, 0xc1, 0xa7, 0xd7, 0x7a, 0xed, 0xf6, - 0xd2, 0x05, 0x2e, 0x37, 0xe3, 0x6b, 0xe3, 0x18, 0x84, 0x66, 0x3d, 0xf2, 0xa2, 0xf2, 0xa4, 0xfa, - 0x50, 0xe2, 0x1e, 0x5d, 0x7b, 0x52, 0x69, 0xa5, 0x7b, 0x40, 0xe8, 0xc6, 0xc5, 0x87, 0xb8, 0x30, - 0xed, 0xc0, 0xb2, 0xd2, 0xf8, 0xfa, 0x17, 0xc9, 0xd2, 0x52, 0xc2, 0x54, 0xb2, 0x7c, 0x67, 0x60, - 0x4d, 0x3c, 0x01, 0x0b, 0xd9, 0x81, 0x82, 0xd3, 0xde, 0x59, 0x7a, 0x32, 0x0f, 0xd5, 0xb5, 0xb2, - 0x59, 0x95, 0x33, 0x8a, 0xbb, 0x5b, 0x56, 0x36, 0xab, 0xc8, 0x90, 0x13, 0x17, 0x26, 0x9d, 0xf6, - 0x4e, 0xb8, 0xb4, 0xcc, 0xd7, 0x6c, 0x6e, 0x44, 0x62, 0xe3, 0xc1, 0x66, 0x35, 0x44, 0x4e, 0xc2, - 0xfe, 0xf2, 0x84, 0xbe, 0xa8, 0xd1, 0x29, 0x94, 0xdf, 0x35, 0x17, 0x90, 0x95, 0xc7, 0x0b, 0xe5, - 0x7d, 0x0f, 0xb0, 0x88, 0xbd, 0x2f, 0x73, 0xf9, 0x74, 0xb5, 0xc8, 0xc8, 0x25, 0x39, 0x55, 0x32, - 0x3d, 0xb4, 0x38, 0x3d, 0x27, 0x05, 0x86, 0xfd, 0x5d, 0xd0, 0x46, 0xbf, 0x94, 0x17, 0x52, 0x00, - 0x45, 0x37, 0x8c, 0x5c, 0x3f, 0xc7, 0x70, 0xe5, 0x54, 0x5e, 0x65, 0x1e, 0x0d, 0xc1, 0x01, 0x28, - 0x48, 0x31, 0x9a, 0x5e, 0xcb, 0xf5, 0xee, 0xcb, 0xcf, 0xbf, 0x95, 0xbb, 0x7b, 0x91, 0xa0, 0xc9, - 0x01, 0x28, 0x48, 0x91, 0xbb, 0x62, 0x52, 0xe7, 0xf3, 0x1a, 0xfd, 0x66, 0x35, 0x45, 0x2f, 0x39, - 0xb9, 0xef, 0x42, 0x21, 0xec, 0xb8, 0x52, 0x5d, 0x1a, 0x93, 0x56, 0x7d, 0x6b, 0x23, 0x8b, 0x56, - 0x7d, 0x6b, 0x03, 0x19, 0x11, 0xf2, 0x55, 0x0b, 0xc0, 0xe9, 0xec, 0x38, 0x61, 0xe8, 0x34, 0xb5, - 0x75, 0x66, 0xcc, 0xf7, 0x12, 0x2a, 0x1a, 0x5f, 0x8a, 0x34, 0x77, 0xa8, 0x8d, 0xa1, 0x68, 0x50, - 0x26, 0xef, 0xc0, 0xb4, 0x23, 0x5e, 0x66, 0x93, 0xbe, 0xe1, 0xf9, 0x3c, 0x37, 0x98, 0xe2, 0x80, - 0x9b, 0x69, 0x24, 0x08, 0x15, 0x41, 0x46, 0x3b, 0x0a, 0x1c, 0xba, 0xeb, 0xee, 0x4b, 0xe3, 0x50, - 0x7d, 0xec, 0x27, 0x13, 0x18, 0xb2, 0x2c, 0xda, 0x12, 0x84, 0x8a, 0xa0, 0x78, 0x29, 0xdb, 0xf1, - 0x1c, 0x1d, 0xf1, 0x97, 0x4f, 0x5c, 0xa8, 0x19, 0x43, 0x68, 0xbc, 0x94, 0x6d, 0x12, 0xc2, 0x24, - 0x5d, 0x72, 0x00, 0x53, 0x0e, 0x7f, 0x33, 0x52, 0x1e, 0xc5, 0x30, 0x8f, 0xf7, 0x27, 0x53, 0x7d, - 0xc0, 0x85, 0x8b, 0x7c, 0x99, 0x52, 0x52, 0x23, 0xbf, 0x61, 0xc1, 0xb4, 0x70, 0x5b, 0x66, 0x0a, - 0x29, 0xfb, 0xf6, 0x2f, 0x9c, 0x42, 0x7e, 0x76, 0xe9, 0x52, 0x2d, 0x9d, 0x90, 0x3e, 0xaa, 0x7d, - 0x32, 0x45, 0xe9, 0x89, 0x4e, 0xd5, 0x8a, 0xbb, 0xe5, 0x4f, 0xc1, 0x9c, 0x89, 0x65, 0x24, 0xb7, - 0xea, 0x1f, 0x17, 0x00, 0x78, 0x47, 0x8b, 0x1c, 0x1f, 0x1d, 0x9e, 0x4c, 0x76, 0xcf, 0x6f, 0xe6, - 0xf3, 0xd8, 0xa7, 0x99, 0xaa, 0x03, 0x64, 0xe6, 0xd8, 0x3d, 0xbf, 0x89, 0x92, 0x08, 0x69, 0xc1, - 0x64, 0xd7, 0x89, 0xf6, 0xf2, 0xcf, 0x0b, 0x32, 0x23, 0x82, 0x5d, 0xa3, 0x3d, 0xe4, 0x04, 0xc8, - 0x7b, 0x56, 0xec, 0x1a, 0x53, 0xc8, 0xc7, 0x81, 0x41, 0xf5, 0xd9, 0x8a, 0x74, 0x86, 0x11, 0x23, - 0x38, 0xd0, 0x45, 0x66, 0xf9, 0x7d, 0x0b, 0xe6, 0xcc, 0xaa, 0x19, 0xc3, 0xf4, 0x73, 0xe6, 0x30, - 0xe5, 0xd9, 0x1f, 0xe6, 0x88, 0xff, 0x37, 0x0b, 0x8c, 0xd7, 0xdb, 0x63, 0xef, 0x71, 0x6b, 0x68, - 0xef, 0xf1, 0x89, 0x11, 0xbd, 0xc7, 0x0b, 0x23, 0x79, 0x8f, 0x4f, 0x8e, 0xee, 0x3d, 0x5e, 0x1c, - 0xec, 0x3d, 0x6e, 0x7f, 0xd3, 0x82, 0xb3, 0x7d, 0xbb, 0x0d, 0xd3, 0x83, 0x03, 0xdf, 0x8f, 0x06, - 0x78, 0x5d, 0x62, 0x0c, 0x42, 0xb3, 0x1e, 0x59, 0x87, 0x45, 0xf9, 0x74, 0x42, 0xbd, 0xdb, 0x76, - 0x33, 0x73, 0xb6, 0x6c, 0xa7, 0xe0, 0xd8, 0xd7, 0xc2, 0xfe, 0xae, 0x05, 0xb3, 0x46, 0xa4, 0x37, - 0xfb, 0x0e, 0x1e, 0x11, 0x2f, 0xd9, 0x88, 0x9d, 0xe4, 0xf8, 0x45, 0x95, 0x80, 0x89, 0x3b, 0xd3, - 0x96, 0x91, 0x58, 0x3b, 0xbe, 0x33, 0x65, 0xa5, 0x28, 0xa1, 0x22, 0x65, 0x32, 0xed, 0xf2, 0x4e, - 0x2f, 0x98, 0x29, 0x93, 0x69, 0x17, 0x39, 0x84, 0x93, 0x63, 0x07, 0x02, 0x19, 0x58, 0x60, 0x3c, - 0x52, 0xe1, 0x04, 0x11, 0x0a, 0x18, 0xb9, 0x04, 0x05, 0xea, 0x35, 0xa5, 0xf5, 0x42, 0x3f, 0x23, - 0x79, 0xd5, 0x6b, 0x22, 0x2b, 0xb7, 0xdf, 0x84, 0xb9, 0x3a, 0x6d, 0x04, 0x34, 0x7a, 0x83, 0x1e, - 0x0e, 0xfd, 0x2e, 0x25, 0x9b, 0xed, 0xa9, 0x77, 0x29, 0x59, 0x73, 0x56, 0x6e, 0xff, 0x33, 0x0b, - 0x52, 0x2f, 0xa9, 0x18, 0xf7, 0x27, 0xd6, 0xc0, 0xfb, 0x13, 0xd3, 0xe6, 0x3e, 0x71, 0xa2, 0xcd, - 0xfd, 0x06, 0x90, 0x0e, 0x5b, 0x0a, 0x89, 0x77, 0x83, 0xa4, 0xe1, 0x28, 0xce, 0x2b, 0xd1, 0x57, - 0x03, 0x33, 0x5a, 0xd9, 0xff, 0x54, 0x30, 0x6b, 0xbe, 0xad, 0xf2, 0xf0, 0x0e, 0xe8, 0x41, 0x91, - 0xa3, 0x92, 0xd6, 0xb3, 0x31, 0x2d, 0xcf, 0xfd, 0xf9, 0x99, 0xe2, 0x81, 0x94, 0x4b, 0x9e, 0x53, - 0xb3, 0xff, 0x48, 0xf0, 0x6a, 0x3c, 0xbe, 0x32, 0x04, 0xaf, 0x9d, 0x24, 0xaf, 0xd7, 0xf3, 0x92, - 0x95, 0xd9, 0x3c, 0x92, 0x15, 0x80, 0x2e, 0x0d, 0x1a, 0xd4, 0x8b, 0x54, 0xbc, 0x4b, 0x51, 0x46, - 0x5e, 0xea, 0x52, 0x34, 0x6a, 0xd8, 0xdf, 0x60, 0x0b, 0x28, 0x76, 0x2b, 0x25, 0x57, 0xd2, 0xbe, - 0xa2, 0xe9, 0xc5, 0xa1, 0x5d, 0x45, 0x8d, 0x28, 0x88, 0x89, 0x87, 0x44, 0x41, 0x7c, 0x04, 0xa6, - 0x03, 0xbf, 0x4d, 0x2b, 0x81, 0x97, 0x76, 0x70, 0x41, 0x56, 0x8c, 0x37, 0x51, 0xc1, 0xed, 0x5f, - 0xb3, 0x60, 0x31, 0x1d, 0xa6, 0x95, 0xbb, 0x03, 0xab, 0x19, 0x4b, 0x5e, 0x18, 0x3d, 0x96, 0xdc, - 0x7e, 0x8f, 0x31, 0x19, 0xb9, 0x8d, 0x7d, 0xd7, 0x13, 0xe1, 0xd7, 0xac, 0xe7, 0x3e, 0x02, 0xd3, - 0x54, 0xbe, 0x3c, 0x29, 0x8c, 0xc0, 0x9a, 0x49, 0xf5, 0xe0, 0xa4, 0x82, 0x93, 0x0a, 0x2c, 0xa8, - 0xab, 0x2f, 0x65, 0xb9, 0x17, 0x69, 0x23, 0xb4, 0xa5, 0x70, 0x3d, 0x09, 0xc6, 0x74, 0x7d, 0xfb, - 0x4b, 0x30, 0x6b, 0x6c, 0x4a, 0x5c, 0x7e, 0xdf, 0x77, 0x1a, 0x51, 0x5a, 0xee, 0x5d, 0x65, 0x85, - 0x28, 0x60, 0xfc, 0x82, 0x41, 0x44, 0x91, 0xa4, 0xe4, 0x9e, 0x8c, 0x1d, 0x91, 0x50, 0x86, 0x2c, - 0xa0, 0x2d, 0x7a, 0x5f, 0xe5, 0x3d, 0x57, 0xc8, 0x90, 0x15, 0xa2, 0x80, 0xd9, 0xcf, 0xc3, 0x8c, - 0x4a, 0xee, 0xc3, 0x33, 0x64, 0x28, 0xe3, 0xb7, 0x99, 0x21, 0xc3, 0x0f, 0x22, 0xe4, 0x10, 0xfb, - 0x2d, 0x98, 0x51, 0x39, 0x88, 0x1e, 0x5e, 0x9b, 0x89, 0xa2, 0xd0, 0x73, 0xaf, 0xfb, 0x61, 0xa4, - 0x12, 0x27, 0x89, 0xfb, 0xb9, 0x9b, 0x1b, 0xbc, 0x0c, 0x35, 0xd4, 0x7e, 0x11, 0x16, 0x52, 0xf7, - 0xb4, 0x43, 0xa4, 0xd3, 0xf8, 0xbd, 0x02, 0xcc, 0x99, 0xd7, 0x75, 0x43, 0xac, 0xe2, 0xe1, 0x85, - 0x63, 0xc6, 0x15, 0x5b, 0x61, 0xc4, 0x2b, 0x36, 0xf3, 0x4e, 0x73, 0xf2, 0x74, 0xef, 0x34, 0x8b, - 0xf9, 0xdc, 0x69, 0x1a, 0x77, 0xef, 0x53, 0x8f, 0xef, 0xee, 0xfd, 0x77, 0x8a, 0x30, 0x9f, 0xcc, - 0xcf, 0x38, 0xc4, 0x48, 0x3e, 0xdf, 0x37, 0x92, 0x23, 0xda, 0xf4, 0x0b, 0xe3, 0xda, 0xf4, 0x27, - 0xc7, 0xb5, 0xe9, 0x17, 0x1f, 0xc1, 0xa6, 0xdf, 0x6f, 0x91, 0x9f, 0x1a, 0xda, 0x22, 0xff, 0x69, - 0xed, 0x95, 0x37, 0x9d, 0x70, 0x63, 0x89, 0xbd, 0xf2, 0x48, 0x72, 0x18, 0xd6, 0xfc, 0x66, 0xa6, - 0x77, 0xe3, 0xcc, 0x43, 0x6c, 0x97, 0x41, 0xa6, 0x13, 0xdd, 0xe8, 0xd7, 0x86, 0x1f, 0x1a, 0xc1, - 0x81, 0xee, 0x65, 0x98, 0x95, 0xf3, 0x89, 0xab, 0xa0, 0x90, 0x54, 0x5f, 0xeb, 0x31, 0x08, 0xcd, - 0x7a, 0xfc, 0xe9, 0xee, 0xe4, 0xcb, 0xe6, 0xfc, 0x8a, 0xc4, 0x7c, 0xba, 0x3b, 0xf5, 0x12, 0x7a, - 0xba, 0xbe, 0xfd, 0x45, 0xb8, 0x90, 0x69, 0x46, 0xe0, 0x26, 0x5c, 0xae, 0x1d, 0xd1, 0xa6, 0xac, - 0x60, 0xb0, 0x91, 0x4a, 0xf9, 0xbf, 0x7c, 0x67, 0x60, 0x4d, 0x3c, 0x01, 0x8b, 0xfd, 0x9d, 0x02, - 0xcc, 0x27, 0xdf, 0x7d, 0x24, 0xf7, 0xb4, 0xd1, 0x31, 0x17, 0x7b, 0xa7, 0x40, 0x6b, 0xe4, 0xfc, - 0x1b, 0x78, 0x59, 0x71, 0x8f, 0xcf, 0xaf, 0x1d, 0x9d, 0x80, 0xf0, 0xf4, 0x08, 0xcb, 0x5b, 0x02, - 0x49, 0x8e, 0x3f, 0xed, 0x18, 0x87, 0x07, 0xca, 0xd3, 0x6c, 0xee, 0xd4, 0xe3, 0x88, 0x3d, 0x4d, - 0x0a, 0x0d, 0xb2, 0x6c, 0x6f, 0x39, 0xa0, 0x81, 0xbb, 0xeb, 0xea, 0x37, 0xab, 0xb9, 0xe4, 0x7e, - 0x4b, 0x96, 0xa1, 0x86, 0xda, 0xef, 0x4d, 0x40, 0xfc, 0x9e, 0x3f, 0x7f, 0x1c, 0x2d, 0x34, 0x4e, - 0x0e, 0x72, 0xd8, 0x6e, 0x8c, 0xfb, 0x02, 0x61, 0x8c, 0x51, 0x7a, 0x4c, 0x1b, 0x25, 0x98, 0xa0, - 0xf8, 0x13, 0x78, 0xc7, 0xdf, 0x81, 0x85, 0x54, 0x3a, 0x8a, 0xdc, 0x73, 0xb6, 0xfe, 0xa8, 0x00, - 0x25, 0x1d, 0xae, 0x43, 0x3e, 0x99, 0x30, 0xe3, 0x94, 0xaa, 0x1f, 0x36, 0x5e, 0xee, 0xd9, 0xf3, - 0x9b, 0x0f, 0x8e, 0xca, 0x0b, 0xba, 0x72, 0xca, 0x24, 0x73, 0x09, 0x0a, 0xbd, 0xa0, 0x9d, 0x3e, - 0xa7, 0xdd, 0xc6, 0x4d, 0x64, 0xe5, 0x66, 0x88, 0x51, 0xe1, 0xb1, 0x86, 0x18, 0xb1, 0x5d, 0x72, - 0xc7, 0x6f, 0x1e, 0xa6, 0x5f, 0xfa, 0xa9, 0xfa, 0xcd, 0x43, 0xe4, 0x10, 0xf2, 0x1a, 0xcc, 0xcb, - 0xb8, 0x29, 0xf3, 0xfd, 0xf3, 0x42, 0x7c, 0xf9, 0xbe, 0x9d, 0x80, 0x62, 0xaa, 0x36, 0xdb, 0x65, - 0xef, 0x86, 0xbe, 0xc7, 0x33, 0xf1, 0x4e, 0x25, 0x6f, 0xea, 0x6e, 0xd4, 0xdf, 0xbc, 0xc9, 0xcd, - 0x49, 0xba, 0x46, 0x22, 0x34, 0x6b, 0xfa, 0xa1, 0xa1, 0x59, 0xeb, 0x02, 0x37, 0xe3, 0x96, 0xef, - 0x28, 0x73, 0xd5, 0x2b, 0x0a, 0x2f, 0x2b, 0x7b, 0x70, 0x74, 0x82, 0xa1, 0x4f, 0xb7, 0xb4, 0x6f, - 0xc3, 0x42, 0xaa, 0xc3, 0xd4, 0xb9, 0xda, 0xca, 0x3e, 0x57, 0x0f, 0xf7, 0x38, 0xcf, 0xbf, 0xb0, - 0xe0, 0x6c, 0x9f, 0x08, 0x18, 0x36, 0x82, 0x30, 0xbd, 0x19, 0x4d, 0x3c, 0xfa, 0x66, 0x54, 0x18, - 0x6d, 0x33, 0xaa, 0xee, 0x7c, 0xef, 0x87, 0x97, 0x9f, 0xf8, 0xfe, 0x0f, 0x2f, 0x3f, 0xf1, 0xc7, - 0x3f, 0xbc, 0xfc, 0xc4, 0x7b, 0xc7, 0x97, 0xad, 0xef, 0x1d, 0x5f, 0xb6, 0xbe, 0x7f, 0x7c, 0xd9, - 0xfa, 0xe3, 0xe3, 0xcb, 0xd6, 0x7f, 0x3a, 0xbe, 0x6c, 0x7d, 0xf3, 0x47, 0x97, 0x9f, 0xf8, 0xec, - 0xa7, 0xe3, 0x09, 0xba, 0xaa, 0x26, 0x28, 0xff, 0xf1, 0x31, 0x35, 0x1d, 0x57, 0xbb, 0xfb, 0xad, - 0x55, 0x36, 0x41, 0x57, 0x75, 0x89, 0x9a, 0xa0, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0xdc, 0xf0, - 0x4e, 0x06, 0x76, 0x9f, 0x00, 0x00, + // 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, } func (m *ALBStatus) Marshal() (dAtA []byte, err error) { @@ -4914,6 +4950,49 @@ func (m *ArgumentValueFrom) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *Authentication) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Authentication) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Authentication) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.OAuth2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Sigv4.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *AwsResourceRef) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7504,6 +7583,53 @@ func (m *NginxTrafficRouting) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *OAuth2Config) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *OAuth2Config) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OAuth2Config) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Scopes) > 0 { + for iNdEx := len(m.Scopes) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Scopes[iNdEx]) + copy(dAtA[i:], m.Scopes[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scopes[iNdEx]))) + i-- + dAtA[i] = 0x22 + } + } + i -= len(m.ClientSecret) + copy(dAtA[i:], m.ClientSecret) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientSecret))) + i-- + dAtA[i] = 0x1a + i -= len(m.ClientID) + copy(dAtA[i:], m.ClientID) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientID))) + i-- + dAtA[i] = 0x12 + i -= len(m.TokenURL) + copy(dAtA[i:], m.TokenURL) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.TokenURL))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *ObjectRef) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7710,39 +7836,6 @@ func (m *PreferredDuringSchedulingIgnoredDuringExecution) MarshalToSizedBuffer(d return len(dAtA) - i, nil } -func (m *PrometheusAuth) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *PrometheusAuth) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PrometheusAuth) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Sigv4.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenerated(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - return len(dAtA) - i, nil -} - func (m *PrometheusMetric) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -9967,6 +10060,16 @@ func (m *WebMetric) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.Authentication.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a if m.JSONBody != nil { i -= len(m.JSONBody) copy(dAtA[i:], m.JSONBody) @@ -10520,6 +10623,19 @@ func (m *ArgumentValueFrom) Size() (n int) { return n } +func (m *Authentication) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Sigv4.Size() + n += 1 + l + sovGenerated(uint64(l)) + l = m.OAuth2.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *AwsResourceRef) Size() (n int) { if m == nil { return 0 @@ -11480,6 +11596,27 @@ func (m *NginxTrafficRouting) Size() (n int) { return n } +func (m *OAuth2Config) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.TokenURL) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ClientID) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.ClientSecret) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Scopes) > 0 { + for _, s := range m.Scopes { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + func (m *ObjectRef) Size() (n int) { if m == nil { return 0 @@ -11556,17 +11693,6 @@ func (m *PreferredDuringSchedulingIgnoredDuringExecution) Size() (n int) { return n } -func (m *PrometheusAuth) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Sigv4.Size() - n += 1 + l + sovGenerated(uint64(l)) - return n -} - func (m *PrometheusMetric) Size() (n int) { if m == nil { return 0 @@ -12394,6 +12520,8 @@ func (m *WebMetric) Size() (n int) { l = len(m.JSONBody) n += 1 + l + sovGenerated(uint64(l)) } + l = m.Authentication.Size() + n += 1 + l + sovGenerated(uint64(l)) return n } @@ -12762,6 +12890,17 @@ func (this *ArgumentValueFrom) String() string { }, "") return s } +func (this *Authentication) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Authentication{`, + `Sigv4:` + strings.Replace(strings.Replace(this.Sigv4.String(), "Sigv4Config", "Sigv4Config", 1), `&`, ``, 1) + `,`, + `OAuth2:` + strings.Replace(strings.Replace(this.OAuth2.String(), "OAuth2Config", "OAuth2Config", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} func (this *AwsResourceRef) String() string { if this == nil { return "nil" @@ -13452,6 +13591,19 @@ func (this *NginxTrafficRouting) String() string { }, "") return s } +func (this *OAuth2Config) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OAuth2Config{`, + `TokenURL:` + fmt.Sprintf("%v", this.TokenURL) + `,`, + `ClientID:` + fmt.Sprintf("%v", this.ClientID) + `,`, + `ClientSecret:` + fmt.Sprintf("%v", this.ClientSecret) + `,`, + `Scopes:` + fmt.Sprintf("%v", this.Scopes) + `,`, + `}`, + }, "") + return s +} func (this *ObjectRef) String() string { if this == nil { return "nil" @@ -13527,16 +13679,6 @@ func (this *PreferredDuringSchedulingIgnoredDuringExecution) String() string { }, "") return s } -func (this *PrometheusAuth) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&PrometheusAuth{`, - `Sigv4:` + strings.Replace(strings.Replace(this.Sigv4.String(), "Sigv4Config", "Sigv4Config", 1), `&`, ``, 1) + `,`, - `}`, - }, "") - return s -} func (this *PrometheusMetric) String() string { if this == nil { return "nil" @@ -13549,7 +13691,7 @@ func (this *PrometheusMetric) String() string { s := strings.Join([]string{`&PrometheusMetric{`, `Address:` + fmt.Sprintf("%v", this.Address) + `,`, `Query:` + fmt.Sprintf("%v", this.Query) + `,`, - `Authentication:` + strings.Replace(strings.Replace(this.Authentication.String(), "PrometheusAuth", "PrometheusAuth", 1), `&`, ``, 1) + `,`, + `Authentication:` + strings.Replace(strings.Replace(this.Authentication.String(), "Authentication", "Authentication", 1), `&`, ``, 1) + `,`, `Timeout:` + valueToStringGenerated(this.Timeout) + `,`, `Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`, `Headers:` + repeatedStringForHeaders + `,`, @@ -14169,6 +14311,7 @@ func (this *WebMetric) String() string { `JSONPath:` + fmt.Sprintf("%v", this.JSONPath) + `,`, `Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`, `JSONBody:` + valueToStringGenerated(this.JSONBody) + `,`, + `Authentication:` + strings.Replace(strings.Replace(this.Authentication.String(), "Authentication", "Authentication", 1), `&`, ``, 1) + `,`, `}`, }, "") return s @@ -17420,6 +17563,122 @@ func (m *ArgumentValueFrom) Unmarshal(dAtA []byte) error { } return nil } +func (m *Authentication) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := 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) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Authentication: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Authentication: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sigv4", 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 err := m.Sigv4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OAuth2", 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 err := m.OAuth2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *AwsResourceRef) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -25859,6 +26118,184 @@ func (m *NginxTrafficRouting) Unmarshal(dAtA []byte) error { } return nil } +func (m *OAuth2Config) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := 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) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OAuth2Config: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OAuth2Config: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenURL", 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.TokenURL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientID", 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.ClientID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientSecret", 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.ClientSecret = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Scopes", 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.Scopes = append(m.Scopes, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *ObjectRef) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -26607,89 +27044,6 @@ func (m *PreferredDuringSchedulingIgnoredDuringExecution) Unmarshal(dAtA []byte) } return nil } -func (m *PrometheusAuth) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := 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) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PrometheusAuth: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PrometheusAuth: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sigv4", 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 err := m.Sigv4.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGenerated(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGenerated - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *PrometheusMetric) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -33890,6 +34244,39 @@ func (m *WebMetric) Unmarshal(dAtA []byte) error { m.JSONBody = []byte{} } iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authentication", 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 err := m.Authentication.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/pkg/apis/rollouts/v1alpha1/generated.proto b/pkg/apis/rollouts/v1alpha1/generated.proto index ea7c60a531..e9ca26687b 100644 --- a/pkg/apis/rollouts/v1alpha1/generated.proto +++ b/pkg/apis/rollouts/v1alpha1/generated.proto @@ -303,6 +303,17 @@ message ArgumentValueFrom { optional FieldRef fieldRef = 2; } +// Authentication method +message Authentication { + // Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus + // +optional + optional Sigv4Config sigv4 = 1; + + // OAuth2 config + // +optional + optional OAuth2Config oauth2 = 2; +} + message AwsResourceRef { optional string name = 1; @@ -1081,6 +1092,21 @@ message NginxTrafficRouting { repeated string stableIngresses = 4; } +message OAuth2Config { + // OAuth2 provider token URL + optional string tokenUrl = 1; + + // OAuth2 client ID + optional string clientId = 2; + + // OAuth2 client secret + optional string clientSecret = 3; + + // OAuth2 scopes + // +optional + repeated string scopes = 4; +} + // ObjectRef holds a references to the Kubernetes object message ObjectRef { // API Version of the referent @@ -1126,12 +1152,6 @@ message PreferredDuringSchedulingIgnoredDuringExecution { optional int32 weight = 1; } -// PrometheusMetric defines the prometheus query to perform canary analysis -message PrometheusAuth { - // +optional - optional Sigv4Config sigv4 = 3; -} - // PrometheusMetric defines the prometheus query to perform canary analysis message PrometheusMetric { // Address is the HTTP address and port of the prometheus server @@ -1140,9 +1160,9 @@ message PrometheusMetric { // Query is a raw prometheus query to perform optional string query = 2; - // Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus + // Authentication details // +optional - optional PrometheusAuth authentication = 3; + optional Authentication authentication = 3; // Timeout represents the duration within which a prometheus query should complete. It is expressed in seconds. // +optional @@ -1847,6 +1867,10 @@ message WebMetric { // +kubebuilder:validation:Type=object // JSONBody is the body of the web metric in a json format (method must be POST/PUT) optional bytes jsonBody = 8; + + // Authentication details + // +optional + optional Authentication authentication = 9; } message WebMetricHeader { diff --git a/pkg/apis/rollouts/v1alpha1/openapi_generated.go b/pkg/apis/rollouts/v1alpha1/openapi_generated.go index f91a313c76..28a35188c5 100644 --- a/pkg/apis/rollouts/v1alpha1/openapi_generated.go +++ b/pkg/apis/rollouts/v1alpha1/openapi_generated.go @@ -52,6 +52,7 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AppMeshVirtualService": schema_pkg_apis_rollouts_v1alpha1_AppMeshVirtualService(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Argument": schema_pkg_apis_rollouts_v1alpha1_Argument(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ArgumentValueFrom": schema_pkg_apis_rollouts_v1alpha1_ArgumentValueFrom(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Authentication": schema_pkg_apis_rollouts_v1alpha1_Authentication(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.AwsResourceRef": schema_pkg_apis_rollouts_v1alpha1_AwsResourceRef(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStatus": schema_pkg_apis_rollouts_v1alpha1_BlueGreenStatus(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.BlueGreenStrategy": schema_pkg_apis_rollouts_v1alpha1_BlueGreenStrategy(ref), @@ -93,12 +94,12 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.MetricResult": schema_pkg_apis_rollouts_v1alpha1_MetricResult(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NewRelicMetric": schema_pkg_apis_rollouts_v1alpha1_NewRelicMetric(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.NginxTrafficRouting": schema_pkg_apis_rollouts_v1alpha1_NginxTrafficRouting(ref), + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.OAuth2Config": schema_pkg_apis_rollouts_v1alpha1_OAuth2Config(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.ObjectRef": schema_pkg_apis_rollouts_v1alpha1_ObjectRef(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PauseCondition": schema_pkg_apis_rollouts_v1alpha1_PauseCondition(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PingPongSpec": schema_pkg_apis_rollouts_v1alpha1_PingPongSpec(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PodTemplateMetadata": schema_pkg_apis_rollouts_v1alpha1_PodTemplateMetadata(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PreferredDuringSchedulingIgnoredDuringExecution": schema_pkg_apis_rollouts_v1alpha1_PreferredDuringSchedulingIgnoredDuringExecution(ref), - "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusAuth": schema_pkg_apis_rollouts_v1alpha1_PrometheusAuth(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusMetric": schema_pkg_apis_rollouts_v1alpha1_PrometheusMetric(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RequiredDuringSchedulingIgnoredDuringExecution": schema_pkg_apis_rollouts_v1alpha1_RequiredDuringSchedulingIgnoredDuringExecution(ref), "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.RollbackWindowSpec": schema_pkg_apis_rollouts_v1alpha1_RollbackWindowSpec(ref), @@ -1099,6 +1100,35 @@ func schema_pkg_apis_rollouts_v1alpha1_ArgumentValueFrom(ref common.ReferenceCal } } +func schema_pkg_apis_rollouts_v1alpha1_Authentication(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "Authentication method", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "sigv4": { + SchemaProps: spec.SchemaProps{ + Description: "Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config"), + }, + }, + "oauth2": { + SchemaProps: spec.SchemaProps{ + Description: "OAuth2 config", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.OAuth2Config"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.OAuth2Config", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config"}, + } +} + func schema_pkg_apis_rollouts_v1alpha1_AwsResourceRef(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -3242,6 +3272,54 @@ func schema_pkg_apis_rollouts_v1alpha1_NginxTrafficRouting(ref common.ReferenceC } } +func schema_pkg_apis_rollouts_v1alpha1_OAuth2Config(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "tokenUrl": { + SchemaProps: spec.SchemaProps{ + Description: "OAuth2 provider token URL", + Type: []string{"string"}, + Format: "", + }, + }, + "clientId": { + SchemaProps: spec.SchemaProps{ + Description: "OAuth2 client ID", + Type: []string{"string"}, + Format: "", + }, + }, + "clientSecret": { + SchemaProps: spec.SchemaProps{ + Description: "OAuth2 client secret", + Type: []string{"string"}, + Format: "", + }, + }, + "scopes": { + SchemaProps: spec.SchemaProps{ + Description: "OAuth2 scopes", + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + func schema_pkg_apis_rollouts_v1alpha1_ObjectRef(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -3402,27 +3480,6 @@ func schema_pkg_apis_rollouts_v1alpha1_PreferredDuringSchedulingIgnoredDuringExe } } -func schema_pkg_apis_rollouts_v1alpha1_PrometheusAuth(ref common.ReferenceCallback) common.OpenAPIDefinition { - return common.OpenAPIDefinition{ - Schema: spec.Schema{ - SchemaProps: spec.SchemaProps{ - Description: "PrometheusMetric defines the prometheus query to perform canary analysis", - Type: []string{"object"}, - Properties: map[string]spec.Schema{ - "sigv4": { - SchemaProps: spec.SchemaProps{ - Default: map[string]interface{}{}, - Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config"), - }, - }, - }, - }, - }, - Dependencies: []string{ - "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Sigv4Config"}, - } -} - func schema_pkg_apis_rollouts_v1alpha1_PrometheusMetric(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -3446,9 +3503,9 @@ func schema_pkg_apis_rollouts_v1alpha1_PrometheusMetric(ref common.ReferenceCall }, "authentication": { SchemaProps: spec.SchemaProps{ - Description: "Sigv4 Config is the aws SigV4 configuration to use for SigV4 signing if using Amazon Managed Prometheus", + Description: "Authentication details", Default: map[string]interface{}{}, - Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusAuth"), + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Authentication"), }, }, "timeout": { @@ -3489,7 +3546,7 @@ func schema_pkg_apis_rollouts_v1alpha1_PrometheusMetric(ref common.ReferenceCall }, }, Dependencies: []string{ - "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.PrometheusAuth", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"}, + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Authentication", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"}, } } @@ -5458,12 +5515,19 @@ func schema_pkg_apis_rollouts_v1alpha1_WebMetric(ref common.ReferenceCallback) c Format: "byte", }, }, + "authentication": { + SchemaProps: spec.SchemaProps{ + Description: "Authentication details", + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Authentication"), + }, + }, }, Required: []string{"url"}, }, }, Dependencies: []string{ - "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"}, + "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.Authentication", "github.com/argoproj/argo-rollouts/pkg/apis/rollouts/v1alpha1.WebMetricHeader"}, } } diff --git a/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go index 2ec2d88b97..aec01a262c 100644 --- a/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/rollouts/v1alpha1/zz_generated.deepcopy.go @@ -615,6 +615,24 @@ func (in *ArgumentValueFrom) DeepCopy() *ArgumentValueFrom { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Authentication) DeepCopyInto(out *Authentication) { + *out = *in + out.Sigv4 = in.Sigv4 + in.OAuth2.DeepCopyInto(&out.OAuth2) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Authentication. +func (in *Authentication) DeepCopy() *Authentication { + if in == nil { + return nil + } + out := new(Authentication) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *AwsResourceRef) DeepCopyInto(out *AwsResourceRef) { *out = *in @@ -1805,6 +1823,27 @@ func (in *NginxTrafficRouting) DeepCopy() *NginxTrafficRouting { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OAuth2Config) DeepCopyInto(out *OAuth2Config) { + *out = *in + if in.Scopes != nil { + in, out := &in.Scopes, &out.Scopes + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OAuth2Config. +func (in *OAuth2Config) DeepCopy() *OAuth2Config { + if in == nil { + return nil + } + out := new(OAuth2Config) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ObjectRef) DeepCopyInto(out *ObjectRef) { *out = *in @@ -1900,27 +1939,10 @@ func (in *PreferredDuringSchedulingIgnoredDuringExecution) DeepCopy() *Preferred return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *PrometheusAuth) DeepCopyInto(out *PrometheusAuth) { - *out = *in - out.Sigv4 = in.Sigv4 - return -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusAuth. -func (in *PrometheusAuth) DeepCopy() *PrometheusAuth { - if in == nil { - return nil - } - out := new(PrometheusAuth) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PrometheusMetric) DeepCopyInto(out *PrometheusMetric) { *out = *in - out.Authentication = in.Authentication + in.Authentication.DeepCopyInto(&out.Authentication) if in.Timeout != nil { in, out := &in.Timeout, &out.Timeout *out = new(int64) @@ -2925,6 +2947,7 @@ func (in *WebMetric) DeepCopyInto(out *WebMetric) { *out = make(json.RawMessage, len(*in)) copy(*out, *in) } + in.Authentication.DeepCopyInto(&out.Authentication) return }