From 6133d84835c59f157a8fb4596f98d2d3cf828bef Mon Sep 17 00:00:00 2001 From: Nikhita Raghunath Date: Mon, 12 Jun 2017 01:42:50 +0530 Subject: [PATCH 1/6] Add types for validation of CustomResources Remove protobuf generation because of the interface type Add custom fuzzer funcs Add custom marshalling Add custom conversion functions move jsonschema types to separate file --- .../pkg/apis/apiextensions/BUILD | 2 + .../pkg/apis/apiextensions/deepcopy.go | 279 ++++++++++++++++++ .../pkg/apis/apiextensions/fuzzer/fuzzer.go | 61 ++++ .../pkg/apis/apiextensions/types.go | 9 +- .../apis/apiextensions/types_jsonschema.go | 96 ++++++ .../pkg/apis/apiextensions/v1beta1/BUILD | 19 ++ .../apis/apiextensions/v1beta1/conversion.go | 73 +++++ .../apiextensions/v1beta1/conversion_test.go | 113 +++++++ .../apis/apiextensions/v1beta1/deepcopy.go | 257 ++++++++++++++++ .../pkg/apis/apiextensions/v1beta1/marshal.go | 134 +++++++++ .../apiextensions/v1beta1/marshal_test.go | 150 ++++++++++ .../apis/apiextensions/v1beta1/register.go | 9 +- .../pkg/apis/apiextensions/v1beta1/types.go | 11 +- .../apiextensions/v1beta1/types_jsonschema.go | 98 ++++++ 14 files changed, 1308 insertions(+), 3 deletions(-) create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/deepcopy.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion_test.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/deepcopy.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal_test.go create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/BUILD index 64088c8a1b0..a7b948801fe 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/BUILD @@ -9,10 +9,12 @@ load( go_library( name = "go_default_library", srcs = [ + "deepcopy.go", "doc.go", "helpers.go", "register.go", "types.go", + "types_jsonschema.go", "zz_generated.deepcopy.go", ], deps = [ diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/deepcopy.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/deepcopy.go new file mode 100644 index 00000000000..dd9680c36f5 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/deepcopy.go @@ -0,0 +1,279 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package apiextensions + +// TODO: Update this after a tag is created for interface fields in DeepCopy +func (in *JSONSchemaProps) DeepCopy() *JSONSchemaProps { + if in == nil { + return nil + } + out := new(JSONSchemaProps) + + *out = *in + + if in.Default != nil { + defaultJSON := JSON(deepCopyJSON(*(in.Default))) + out.Default = &(defaultJSON) + } else { + out.Default = nil + } + + if in.Example != nil { + exampleJSON := JSON(deepCopyJSON(*(in.Example))) + out.Example = &(exampleJSON) + } else { + out.Example = nil + } + + if in.Ref != nil { + in, out := &in.Ref, &out.Ref + if *in == nil { + *out = nil + } else { + *out = new(string) + **out = **in + } + } + + if in.Maximum != nil { + in, out := &in.Maximum, &out.Maximum + if *in == nil { + *out = nil + } else { + *out = new(float64) + **out = **in + } + } + + if in.Minimum != nil { + in, out := &in.Minimum, &out.Minimum + if *in == nil { + *out = nil + } else { + *out = new(float64) + **out = **in + } + } + + if in.MaxLength != nil { + in, out := &in.MaxLength, &out.MaxLength + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MinLength != nil { + in, out := &in.MinLength, &out.MinLength + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + if in.MaxItems != nil { + in, out := &in.MaxItems, &out.MaxItems + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MinItems != nil { + in, out := &in.MinItems, &out.MinItems + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MultipleOf != nil { + in, out := &in.MultipleOf, &out.MultipleOf + if *in == nil { + *out = nil + } else { + *out = new(float64) + **out = **in + } + } + + if in.Enum != nil { + out.Enum = make([]JSON, len(in.Enum)) + for i := range in.Enum { + out.Enum[i] = deepCopyJSON(in.Enum[i]) + } + } + + if in.MaxProperties != nil { + in, out := &in.MaxProperties, &out.MaxProperties + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MinProperties != nil { + in, out := &in.MinProperties, &out.MinProperties + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.Required != nil { + in, out := &in.Required, &out.Required + *out = make([]string, len(*in)) + copy(*out, *in) + } + + if in.Items != nil { + in, out := &in.Items, &out.Items + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaPropsOrArray) + (*in).DeepCopyInto(*out) + } + } + + if in.AllOf != nil { + in, out := &in.AllOf, &out.AllOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + + if in.OneOf != nil { + in, out := &in.OneOf, &out.OneOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.AnyOf != nil { + in, out := &in.AnyOf, &out.AnyOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + + if in.Not != nil { + in, out := &in.Not, &out.Not + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + + if in.Properties != nil { + in, out := &in.Properties, &out.Properties + *out = make(map[string]JSONSchemaProps, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.AdditionalProperties != nil { + in, out := &in.AdditionalProperties, &out.AdditionalProperties + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaPropsOrBool) + (*in).DeepCopyInto(*out) + } + } + + if in.PatternProperties != nil { + in, out := &in.PatternProperties, &out.PatternProperties + *out = make(map[string]JSONSchemaProps, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.Dependencies != nil { + in, out := &in.Dependencies, &out.Dependencies + *out = make(JSONSchemaDependencies, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.AdditionalItems != nil { + in, out := &in.AdditionalItems, &out.AdditionalItems + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaPropsOrBool) + (*in).DeepCopyInto(*out) + } + } + + if in.Definitions != nil { + in, out := &in.Definitions, &out.Definitions + *out = make(JSONSchemaDefinitions, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.ExternalDocs != nil { + in, out := &in.ExternalDocs, &out.ExternalDocs + if *in == nil { + *out = nil + } else { + *out = new(ExternalDocumentation) + (*in).DeepCopyInto(*out) + } + } + + return out +} + +func deepCopyJSON(x interface{}) interface{} { + switch x := x.(type) { + case map[string]interface{}: + clone := make(map[string]interface{}, len(x)) + for k, v := range x { + clone[k] = deepCopyJSON(v) + } + return clone + case []interface{}: + clone := make([]interface{}, len(x)) + for i := range x { + clone[i] = deepCopyJSON(x[i]) + } + return clone + default: + return x + } +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/fuzzer/fuzzer.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/fuzzer/fuzzer.go index 705fc0bd7a1..e4a4352d485 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/fuzzer/fuzzer.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/fuzzer/fuzzer.go @@ -17,6 +17,7 @@ limitations under the License. package fuzzer import ( + "reflect" "strings" "github.com/google/gofuzz" @@ -42,5 +43,65 @@ func Funcs(codecs runtimeserializer.CodecFactory) []interface{} { obj.Names.ListKind = obj.Names.Kind + "List" } }, + func(obj *apiextensions.JSONSchemaProps, c fuzz.Continue) { + // we cannot use c.FuzzNoCustom because of the interface{} fields. So let's loop with reflection. + vobj := reflect.ValueOf(obj).Elem() + tobj := reflect.TypeOf(obj).Elem() + for i := 0; i < tobj.NumField(); i++ { + field := tobj.Field(i) + switch field.Name { + case "Default", "Enum", "Example": + continue + default: + isValue := true + switch field.Type.Kind() { + case reflect.Interface, reflect.Map, reflect.Slice, reflect.Ptr: + isValue = false + } + if isValue || c.Intn(5) == 0 { + c.Fuzz(vobj.Field(i).Addr().Interface()) + } + } + } + if c.RandBool() { + validJSON := apiextensions.JSON(`{"some": {"json": "test"}, "string": 42}`) + obj.Default = &validJSON + } + if c.RandBool() { + obj.Enum = []apiextensions.JSON{c.Float64(), c.RandString(), c.RandBool()} + } + if c.RandBool() { + validJSON := apiextensions.JSON(`"foobarbaz"`) + obj.Example = &validJSON + } + }, + func(obj *apiextensions.JSONSchemaPropsOrBool, c fuzz.Continue) { + if c.RandBool() { + obj.Schema = &apiextensions.JSONSchemaProps{} + c.Fuzz(obj.Schema) + } else { + obj.Allows = c.RandBool() + } + }, + func(obj *apiextensions.JSONSchemaPropsOrArray, c fuzz.Continue) { + // disallow both Schema and JSONSchemas to be nil. + if c.RandBool() { + obj.Schema = &apiextensions.JSONSchemaProps{} + c.Fuzz(obj.Schema) + } else { + obj.JSONSchemas = make([]apiextensions.JSONSchemaProps, c.Intn(3)+1) + for i := range obj.JSONSchemas { + c.Fuzz(&obj.JSONSchemas[i]) + } + } + }, + func(obj *apiextensions.JSONSchemaPropsOrStringArray, c fuzz.Continue) { + if c.RandBool() { + obj.Schema = &apiextensions.JSONSchemaProps{} + c.Fuzz(obj.Schema) + } else { + c.Fuzz(&obj.Property) + } + }, } } diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types.go index 59240fbd008..fba9c90bc26 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types.go @@ -26,9 +26,10 @@ type CustomResourceDefinitionSpec struct { Version string // Names are the names used to describe this custom resource Names CustomResourceDefinitionNames - // Scope indicates whether this resource is cluster or namespace scoped. Default is namespaced Scope ResourceScope + // Validation describes the validation methods for CustomResources + Validation *CustomResourceValidation } // CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition @@ -139,3 +140,9 @@ type CustomResourceDefinitionList struct { // Items individual CustomResourceDefinitions Items []CustomResourceDefinition } + +// CustomResourceValidation is a list of validation methods for CustomResources. +type CustomResourceValidation struct { + // OpenAPIV3Schema is the OpenAPI v3 schema to be validated against. + OpenAPIV3Schema *JSONSchemaProps +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go new file mode 100644 index 00000000000..79f34e8bf65 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/types_jsonschema.go @@ -0,0 +1,96 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package apiextensions + +// JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). +type JSONSchemaProps struct { + ID string + Schema JSONSchemaURL + Ref *string + Description string + Type string + Format string + Title string + Default *JSON + Maximum *float64 + ExclusiveMaximum bool + Minimum *float64 + ExclusiveMinimum bool + MaxLength *int64 + MinLength *int64 + Pattern string + MaxItems *int64 + MinItems *int64 + UniqueItems bool + MultipleOf *float64 + Enum []JSON + MaxProperties *int64 + MinProperties *int64 + Required []string + Items *JSONSchemaPropsOrArray + AllOf []JSONSchemaProps + OneOf []JSONSchemaProps + AnyOf []JSONSchemaProps + Not *JSONSchemaProps + Properties map[string]JSONSchemaProps + AdditionalProperties *JSONSchemaPropsOrBool + PatternProperties map[string]JSONSchemaProps + Dependencies JSONSchemaDependencies + AdditionalItems *JSONSchemaPropsOrBool + Definitions JSONSchemaDefinitions + ExternalDocs *ExternalDocumentation + Example *JSON +} + +// JSON represents any valid JSON value. +// These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. +type JSON interface{} + +// JSONSchemaURL represents a schema url. +type JSONSchemaURL string + +// JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps +// or an array of JSONSchemaProps. Mainly here for serialization purposes. +type JSONSchemaPropsOrArray struct { + Schema *JSONSchemaProps + JSONSchemas []JSONSchemaProps +} + +// JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. +// Defaults to true for the boolean property. +type JSONSchemaPropsOrBool struct { + Allows bool + Schema *JSONSchemaProps +} + +// JSONSchemaDependencies represent a dependencies property. +type JSONSchemaDependencies map[string]JSONSchemaPropsOrStringArray + +// JSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array. +type JSONSchemaPropsOrStringArray struct { + Schema *JSONSchemaProps + Property []string +} + +// JSONSchemaDefinitions contains the models explicitly defined in this spec. +type JSONSchemaDefinitions map[string]JSONSchemaProps + +// ExternalDocumentation allows referencing an external resource for extended documentation. +type ExternalDocumentation struct { + Description string + URL string +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD index 60b91ad1f23..421014e87c8 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD @@ -3,16 +3,21 @@ package(default_visibility = ["//visibility:public"]) load( "@io_bazel_rules_go//go:def.bzl", "go_library", + "go_test", ) go_library( name = "go_default_library", srcs = [ + "conversion.go", + "deepcopy.go", "defaults.go", "doc.go", "generated.pb.go", + "marshal.go", "register.go", "types.go", + "types_jsonschema.go", "zz_generated.conversion.go", "zz_generated.deepcopy.go", "zz_generated.defaults.go", @@ -24,6 +29,7 @@ go_library( "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library", "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library", "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/util/json:go_default_library", ], ) @@ -45,3 +51,16 @@ filegroup( srcs = ["generated.proto"], visibility = ["//visibility:public"], ) + +go_test( + name = "go_default_test", + srcs = [ + "conversion_test.go", + "marshal_test.go", + ], + library = ":go_default_library", + deps = [ + "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library", + ], +) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go new file mode 100644 index 00000000000..f9951009dc9 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion.go @@ -0,0 +1,73 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + "k8s.io/apimachinery/pkg/conversion" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/util/json" + + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" +) + +func addConversionFuncs(scheme *runtime.Scheme) error { + // Add non-generated conversion functions + err := scheme.AddConversionFuncs( + Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps, + Convert_apiextensions_JSON_To_v1beta1_JSON, + Convert_v1beta1_JSON_To_apiextensions_JSON, + ) + if err != nil { + return err + } + return nil +} + +func Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(in *apiextensions.JSONSchemaProps, out *JSONSchemaProps, s conversion.Scope) error { + if err := autoConvert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(in, out, s); err != nil { + return err + } + if in.Default != nil && *(in.Default) == nil { + out.Default = nil + } + if in.Example != nil && *(in.Example) == nil { + out.Example = nil + } + return nil +} + +func Convert_apiextensions_JSON_To_v1beta1_JSON(in *apiextensions.JSON, out *JSON, s conversion.Scope) error { + raw, err := json.Marshal(*in) + if err != nil { + return err + } + out.Raw = raw + return nil +} + +func Convert_v1beta1_JSON_To_apiextensions_JSON(in *JSON, out *apiextensions.JSON, s conversion.Scope) error { + if in != nil { + var i interface{} + if err := json.Unmarshal(in.Raw, &i); err != nil { + return err + } + *out = i + } else { + out = nil + } + return nil +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion_test.go new file mode 100644 index 00000000000..a697dd9e3ac --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/conversion_test.go @@ -0,0 +1,113 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + "reflect" + "testing" + + "k8s.io/apimachinery/pkg/runtime" + + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" +) + +func TestJSONConversion(t *testing.T) { + nilJSON := apiextensions.JSON(nil) + nullJSON := apiextensions.JSON("null") + stringJSON := apiextensions.JSON("foo") + boolJSON := apiextensions.JSON(true) + sliceJSON := apiextensions.JSON([]string{"foo", "bar", "baz"}) + + testCases := map[string]struct { + input *apiextensions.JSONSchemaProps + expected *JSONSchemaProps + }{ + "nil": { + input: &apiextensions.JSONSchemaProps{ + Default: nil, + }, + expected: &JSONSchemaProps{}, + }, + "aliased nil": { + input: &apiextensions.JSONSchemaProps{ + Default: &nilJSON, + }, + expected: &JSONSchemaProps{}, + }, + "null": { + input: &apiextensions.JSONSchemaProps{ + Default: &nullJSON, + }, + expected: &JSONSchemaProps{ + Default: &JSON{ + Raw: []byte(`"null"`), + }, + }, + }, + "string": { + input: &apiextensions.JSONSchemaProps{ + Default: &stringJSON, + }, + expected: &JSONSchemaProps{ + Default: &JSON{ + Raw: []byte(`"foo"`), + }, + }, + }, + "bool": { + input: &apiextensions.JSONSchemaProps{ + Default: &boolJSON, + }, + expected: &JSONSchemaProps{ + Default: &JSON{ + Raw: []byte(`true`), + }, + }, + }, + "slice": { + input: &apiextensions.JSONSchemaProps{ + Default: &sliceJSON, + }, + expected: &JSONSchemaProps{ + Default: &JSON{ + Raw: []byte(`["foo","bar","baz"]`), + }, + }, + }, + } + + scheme := runtime.NewScheme() + + // add internal and external types + if err := apiextensions.AddToScheme(scheme); err != nil { + t.Fatal(err) + } + if err := AddToScheme(scheme); err != nil { + t.Fatal(err) + } + + for k, tc := range testCases { + external := &JSONSchemaProps{} + if err := scheme.Convert(tc.input, external, nil); err != nil { + t.Errorf("%s: unexpected error: %v", k, err) + } + + if !reflect.DeepEqual(external, tc.expected) { + t.Errorf("%s: expected\n\t%#v, got \n\t%#v", k, tc.expected, external) + } + } +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/deepcopy.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/deepcopy.go new file mode 100644 index 00000000000..903773ae213 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/deepcopy.go @@ -0,0 +1,257 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +// TODO: Update this after a tag is created for interface fields in DeepCopy +func (in *JSONSchemaProps) DeepCopy() *JSONSchemaProps { + if in == nil { + return nil + } + out := new(JSONSchemaProps) + *out = *in + + if in.Ref != nil { + in, out := &in.Ref, &out.Ref + if *in == nil { + *out = nil + } else { + *out = new(string) + **out = **in + } + } + + if in.Maximum != nil { + in, out := &in.Maximum, &out.Maximum + if *in == nil { + *out = nil + } else { + *out = new(float64) + **out = **in + } + } + + if in.Minimum != nil { + in, out := &in.Minimum, &out.Minimum + if *in == nil { + *out = nil + } else { + *out = new(float64) + **out = **in + } + } + + if in.MaxLength != nil { + in, out := &in.MaxLength, &out.MaxLength + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MinLength != nil { + in, out := &in.MinLength, &out.MinLength + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + if in.MaxItems != nil { + in, out := &in.MaxItems, &out.MaxItems + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MinItems != nil { + in, out := &in.MinItems, &out.MinItems + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MultipleOf != nil { + in, out := &in.MultipleOf, &out.MultipleOf + if *in == nil { + *out = nil + } else { + *out = new(float64) + **out = **in + } + } + + if in.MaxProperties != nil { + in, out := &in.MaxProperties, &out.MaxProperties + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.MinProperties != nil { + in, out := &in.MinProperties, &out.MinProperties + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + + if in.Required != nil { + in, out := &in.Required, &out.Required + *out = make([]string, len(*in)) + copy(*out, *in) + } + + if in.Items != nil { + in, out := &in.Items, &out.Items + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaPropsOrArray) + (*in).DeepCopyInto(*out) + } + } + + if in.AllOf != nil { + in, out := &in.AllOf, &out.AllOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + + if in.OneOf != nil { + in, out := &in.OneOf, &out.OneOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.AnyOf != nil { + in, out := &in.AnyOf, &out.AnyOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + + if in.Not != nil { + in, out := &in.Not, &out.Not + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + + if in.Properties != nil { + in, out := &in.Properties, &out.Properties + *out = make(map[string]JSONSchemaProps, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.AdditionalProperties != nil { + in, out := &in.AdditionalProperties, &out.AdditionalProperties + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaPropsOrBool) + (*in).DeepCopyInto(*out) + } + } + + if in.PatternProperties != nil { + in, out := &in.PatternProperties, &out.PatternProperties + *out = make(map[string]JSONSchemaProps, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.Dependencies != nil { + in, out := &in.Dependencies, &out.Dependencies + *out = make(JSONSchemaDependencies, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.AdditionalItems != nil { + in, out := &in.AdditionalItems, &out.AdditionalItems + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaPropsOrBool) + (*in).DeepCopyInto(*out) + } + } + + if in.Definitions != nil { + in, out := &in.Definitions, &out.Definitions + *out = make(JSONSchemaDefinitions, len(*in)) + for key, val := range *in { + (*out)[key] = *val.DeepCopy() + } + } + + if in.ExternalDocs != nil { + in, out := &in.ExternalDocs, &out.ExternalDocs + if *in == nil { + *out = nil + } else { + *out = new(ExternalDocumentation) + (*in).DeepCopyInto(*out) + } + } + + return out +} + +func deepCopyJSON(x interface{}) interface{} { + switch x := x.(type) { + case map[string]interface{}: + clone := make(map[string]interface{}, len(x)) + for k, v := range x { + clone[k] = deepCopyJSON(v) + } + return clone + case []interface{}: + clone := make([]interface{}, len(x)) + for i := range x { + clone[i] = deepCopyJSON(x[i]) + } + return clone + default: + return x + } +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go new file mode 100644 index 00000000000..d8f9f164e8c --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal.go @@ -0,0 +1,134 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + "errors" + + "k8s.io/apimachinery/pkg/util/json" +) + +var jsTrue = []byte("true") +var jsFalse = []byte("false") + +func (s JSONSchemaPropsOrBool) MarshalJSON() ([]byte, error) { + if s.Schema != nil { + return json.Marshal(s.Schema) + } + + if s.Schema == nil && !s.Allows { + return jsFalse, nil + } + return jsTrue, nil +} + +func (s *JSONSchemaPropsOrBool) UnmarshalJSON(data []byte) error { + var nw JSONSchemaPropsOrBool + switch { + case len(data) == 0: + case data[0] == '{': + var sch JSONSchemaProps + if err := json.Unmarshal(data, &sch); err != nil { + return err + } + nw.Schema = &sch + case len(data) == 4 && string(data) == "true": + nw.Allows = true + case len(data) == 5 && string(data) == "false": + nw.Allows = false + default: + return errors.New("boolean or JSON schema expected") + } + *s = nw + return nil +} + +func (s JSONSchemaPropsOrStringArray) MarshalJSON() ([]byte, error) { + if len(s.Property) > 0 { + return json.Marshal(s.Property) + } + if s.Schema != nil { + return json.Marshal(s.Schema) + } + return []byte("null"), nil +} + +func (s *JSONSchemaPropsOrStringArray) UnmarshalJSON(data []byte) error { + var first byte + if len(data) > 1 { + first = data[0] + } + var nw JSONSchemaPropsOrStringArray + if first == '{' { + var sch JSONSchemaProps + if err := json.Unmarshal(data, &sch); err != nil { + return err + } + nw.Schema = &sch + } + if first == '[' { + if err := json.Unmarshal(data, &nw.Property); err != nil { + return err + } + } + *s = nw + return nil +} + +func (s JSONSchemaPropsOrArray) MarshalJSON() ([]byte, error) { + if len(s.JSONSchemas) > 0 { + return json.Marshal(s.JSONSchemas) + } + return json.Marshal(s.Schema) +} + +func (s *JSONSchemaPropsOrArray) UnmarshalJSON(data []byte) error { + var nw JSONSchemaPropsOrArray + var first byte + if len(data) > 1 { + first = data[0] + } + if first == '{' { + var sch JSONSchemaProps + if err := json.Unmarshal(data, &sch); err != nil { + return err + } + nw.Schema = &sch + } + if first == '[' { + if err := json.Unmarshal(data, &nw.JSONSchemas); err != nil { + return err + } + } + *s = nw + return nil +} + +func (s JSON) MarshalJSON() ([]byte, error) { + if len(s.Raw) > 0 { + return s.Raw, nil + } + return []byte("null"), nil + +} + +func (s *JSON) UnmarshalJSON(data []byte) error { + if len(data) > 0 && string(data) != "null" { + s.Raw = data + } + return nil +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal_test.go new file mode 100644 index 00000000000..0c6d4d4b525 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/marshal_test.go @@ -0,0 +1,150 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + "encoding/json" + "reflect" + "testing" +) + +type JSONSchemaPropsOrBoolHolder struct { + JSPoB JSONSchemaPropsOrBool `json:"val1"` + JSPoBOmitEmpty *JSONSchemaPropsOrBool `json:"val2,omitempty"` +} + +func TestJSONSchemaPropsOrBoolUnmarshalJSON(t *testing.T) { + cases := []struct { + input string + result JSONSchemaPropsOrBoolHolder + }{ + {`{}`, JSONSchemaPropsOrBoolHolder{}}, + + {`{"val1": {}}`, JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{}}}}, + {`{"val1": {"type":"string"}}`, JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{Type: "string"}}}}, + {`{"val1": false}`, JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{}}}, + {`{"val1": true}`, JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Allows: true}}}, + + {`{"val2": {}}`, JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{}}}}, + {`{"val2": {"type":"string"}}`, JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{Type: "string"}}}}, + {`{"val2": false}`, JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{}}}, + {`{"val2": true}`, JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{Allows: true}}}, + } + + for _, c := range cases { + var result JSONSchemaPropsOrBoolHolder + if err := json.Unmarshal([]byte(c.input), &result); err != nil { + t.Errorf("Failed to unmarshal input '%v': %v", c.input, err) + } + if !reflect.DeepEqual(result, c.result) { + t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result) + } + } +} + +func TestStringArrayOrStringMarshalJSON(t *testing.T) { + cases := []struct { + input JSONSchemaPropsOrBoolHolder + result string + }{ + {JSONSchemaPropsOrBoolHolder{}, `{"val1":false}`}, + + {JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{}}}, `{"val1":{}}`}, + {JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{Type: "string"}}}, `{"val1":{"type":"string"}}`}, + {JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{}}, `{"val1":false}`}, + {JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Allows: true}}, `{"val1":true}`}, + + {JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{}}}, `{"val1":false,"val2":{}}`}, + {JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{Type: "string"}}}, `{"val1":false,"val2":{"type":"string"}}`}, + {JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{}}, `{"val1":false,"val2":false}`}, + {JSONSchemaPropsOrBoolHolder{JSPoBOmitEmpty: &JSONSchemaPropsOrBool{Allows: true}}, `{"val1":false,"val2":true}`}, + } + + for _, c := range cases { + result, err := json.Marshal(&c.input) + if err != nil { + t.Errorf("Unexpected error marshaling input '%v': %v", c.input, err) + } + if string(result) != c.result { + t.Errorf("Failed to marshal input '%v': expected: %q, got %q", c.input, c.result, string(result)) + } + } +} + +type JSONSchemaPropsOrArrayHolder struct { + JSPoA JSONSchemaPropsOrArray `json:"val1"` + JSPoAOmitEmpty *JSONSchemaPropsOrArray `json:"val2,omitempty"` +} + +func TestJSONSchemaPropsOrArrayUnmarshalJSON(t *testing.T) { + cases := []struct { + input string + result JSONSchemaPropsOrArrayHolder + }{ + {`{}`, JSONSchemaPropsOrArrayHolder{}}, + + {`{"val1": {}}`, JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{}}}}, + {`{"val1": {"type":"string"}}`, JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{Type: "string"}}}}, + {`{"val1": [{}]}`, JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}}}}}, + {`{"val1": [{},{"type":"string"}]}`, JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}, {Type: "string"}}}}}, + + {`{"val2": {}}`, JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{}}}}, + {`{"val2": {"type":"string"}}`, JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{Type: "string"}}}}, + {`{"val2": [{}]}`, JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}}}}}, + {`{"val2": [{},{"type":"string"}]}`, JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}, {Type: "string"}}}}}, + } + + for _, c := range cases { + var result JSONSchemaPropsOrArrayHolder + if err := json.Unmarshal([]byte(c.input), &result); err != nil { + t.Errorf("Failed to unmarshal input '%v': %v", c.input, err) + } + if !reflect.DeepEqual(result, c.result) { + t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result) + } + } +} + +func TestJSONSchemaPropsOrArrayMarshalJSON(t *testing.T) { + cases := []struct { + input JSONSchemaPropsOrArrayHolder + result string + }{ + {JSONSchemaPropsOrArrayHolder{}, `{"val1":null}`}, + + {JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{}}}, `{"val1":{}}`}, + {JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{Type: "string"}}}, `{"val1":{"type":"string"}}`}, + {JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}}}}, `{"val1":[{}]}`}, + {JSONSchemaPropsOrArrayHolder{JSPoA: JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}, {Type: "string"}}}}, `{"val1":[{},{"type":"string"}]}`}, + + {JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{}}, `{"val1":null,"val2":null}`}, + {JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{}}}, `{"val1":null,"val2":{}}`}, + {JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{Schema: &JSONSchemaProps{Type: "string"}}}, `{"val1":null,"val2":{"type":"string"}}`}, + {JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}}}}, `{"val1":null,"val2":[{}]}`}, + {JSONSchemaPropsOrArrayHolder{JSPoAOmitEmpty: &JSONSchemaPropsOrArray{JSONSchemas: []JSONSchemaProps{{}, {Type: "string"}}}}, `{"val1":null,"val2":[{},{"type":"string"}]}`}, + } + + for i, c := range cases { + result, err := json.Marshal(&c.input) + if err != nil { + t.Errorf("%d: Unexpected error marshaling input '%v': %v", i, c.input, err) + } + if string(result) != c.result { + t.Errorf("%d: Failed to marshal input '%v': expected: %q, got %q", i, c.input, c.result, string(result)) + } + } +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/register.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/register.go index 8d4c341f7c6..8ced548fa96 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/register.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/register.go @@ -38,7 +38,7 @@ func Resource(resource string) schema.GroupResource { } var ( - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, addDefaultingFuncs) + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, addDefaultingFuncs, addConversionFuncs) localSchemeBuilder = &SchemeBuilder AddToScheme = localSchemeBuilder.AddToScheme ) @@ -52,3 +52,10 @@ func addKnownTypes(scheme *runtime.Scheme) error { metav1.AddToGroupVersion(scheme, SchemeGroupVersion) return nil } + +func init() { + // We only register manually written functions here. The registration of the + // generated functions takes place in the generated files. The separation + // makes the code compile even when the generated files are missing. + localSchemeBuilder.Register(addDefaultingFuncs, addConversionFuncs) +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types.go index 75b41065072..fe61f32151c 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types.go @@ -26,9 +26,12 @@ type CustomResourceDefinitionSpec struct { Version string `json:"version" protobuf:"bytes,2,opt,name=version"` // Names are the names used to describe this custom resource Names CustomResourceDefinitionNames `json:"names" protobuf:"bytes,3,opt,name=names"` - // Scope indicates whether this resource is cluster or namespace scoped. Default is namespaced Scope ResourceScope `json:"scope" protobuf:"bytes,4,opt,name=scope,casttype=ResourceScope"` + // Validation describes the validation methods for CustomResources + // This field is alpha-level and should only be sent to servers that enable the CustomResourceValidation feature. + // +optional + Validation *CustomResourceValidation `json:"validation,omitempty" protobuf:"bytes,5,opt,name=validation"` } // CustomResourceDefinitionNames indicates the names to serve this CustomResourceDefinition @@ -139,3 +142,9 @@ type CustomResourceDefinitionList struct { // Items individual CustomResourceDefinitions Items []CustomResourceDefinition `json:"items" protobuf:"bytes,2,rep,name=items"` } + +// CustomResourceValidation is a list of validation methods for CustomResources. +type CustomResourceValidation struct { + // OpenAPIV3Schema is the OpenAPI v3 schema to be validated against. + OpenAPIV3Schema *JSONSchemaProps `json:"openAPIV3Schema,omitempty" protobuf:"bytes,1,opt,name=openAPIV3Schema"` +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go new file mode 100644 index 00000000000..9edd276d84c --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/types_jsonschema.go @@ -0,0 +1,98 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +// JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). +type JSONSchemaProps struct { + ID string `json:"id,omitempty" protobuf:"bytes,1,opt,name=id"` + Schema JSONSchemaURL `json:"$schema,omitempty" protobuf:"bytes,2,opt,name=schema"` + Ref *string `json:"$ref,omitempty" protobuf:"bytes,3,opt,name=ref"` + Description string `json:"description,omitempty" protobuf:"bytes,4,opt,name=description"` + Type string `json:"type,omitempty" protobuf:"bytes,5,opt,name=type"` + Format string `json:"format,omitempty" protobuf:"bytes,6,opt,name=format"` + Title string `json:"title,omitempty" protobuf:"bytes,7,opt,name=title"` + Default *JSON `json:"default,omitempty" protobuf:"bytes,8,opt,name=default"` + Maximum *float64 `json:"maximum,omitempty" protobuf:"bytes,9,opt,name=maximum"` + ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty" protobuf:"bytes,10,opt,name=exclusiveMaximum"` + Minimum *float64 `json:"minimum,omitempty" protobuf:"bytes,11,opt,name=minimum"` + ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty" protobuf:"bytes,12,opt,name=exclusiveMinimum"` + MaxLength *int64 `json:"maxLength,omitempty" protobuf:"bytes,13,opt,name=maxLength"` + MinLength *int64 `json:"minLength,omitempty" protobuf:"bytes,14,opt,name=minLength"` + Pattern string `json:"pattern,omitempty" protobuf:"bytes,15,opt,name=pattern"` + MaxItems *int64 `json:"maxItems,omitempty" protobuf:"bytes,16,opt,name=maxItems"` + MinItems *int64 `json:"minItems,omitempty" protobuf:"bytes,17,opt,name=minItems"` + UniqueItems bool `json:"uniqueItems,omitempty" protobuf:"bytes,18,opt,name=uniqueItems"` + MultipleOf *float64 `json:"multipleOf,omitempty" protobuf:"bytes,19,opt,name=multipleOf"` + Enum []JSON `json:"enum,omitempty" protobuf:"bytes,20,rep,name=enum"` + MaxProperties *int64 `json:"maxProperties,omitempty" protobuf:"bytes,21,opt,name=maxProperties"` + MinProperties *int64 `json:"minProperties,omitempty" protobuf:"bytes,22,opt,name=minProperties"` + Required []string `json:"required,omitempty" protobuf:"bytes,23,rep,name=required"` + Items *JSONSchemaPropsOrArray `json:"items,omitempty" protobuf:"bytes,24,opt,name=items"` + AllOf []JSONSchemaProps `json:"allOf,omitempty" protobuf:"bytes,25,rep,name=allOf"` + OneOf []JSONSchemaProps `json:"oneOf,omitempty" protobuf:"bytes,26,rep,name=oneOf"` + AnyOf []JSONSchemaProps `json:"anyOf,omitempty" protobuf:"bytes,27,rep,name=anyOf"` + Not *JSONSchemaProps `json:"not,omitempty" protobuf:"bytes,28,opt,name=not"` + Properties map[string]JSONSchemaProps `json:"properties,omitempty" protobuf:"bytes,29,rep,name=properties"` + AdditionalProperties *JSONSchemaPropsOrBool `json:"additionalProperties,omitempty" protobuf:"bytes,30,opt,name=additionalProperties"` + PatternProperties map[string]JSONSchemaProps `json:"patternProperties,omitempty" protobuf:"bytes,31,rep,name=patternProperties"` + Dependencies JSONSchemaDependencies `json:"dependencies,omitempty" protobuf:"bytes,32,opt,name=dependencies"` + AdditionalItems *JSONSchemaPropsOrBool `json:"additionalItems,omitempty" protobuf:"bytes,33,opt,name=additionalItems"` + Definitions JSONSchemaDefinitions `json:"definitions,omitempty" protobuf:"bytes,34,opt,name=definitions"` + ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty" protobuf:"bytes,35,opt,name=externalDocs"` + Example *JSON `json:"example,omitempty" protobuf:"bytes,36,opt,name=example"` +} + +// JSON represents any valid JSON value. +// These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. +type JSON struct { + Raw []byte `protobuf:"bytes,1,opt,name=raw"` +} + +// JSONSchemaURL represents a schema url. +type JSONSchemaURL string + +// JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps +// or an array of JSONSchemaProps. Mainly here for serialization purposes. +type JSONSchemaPropsOrArray struct { + Schema *JSONSchemaProps `protobuf:"bytes,1,opt,name=schema"` + JSONSchemas []JSONSchemaProps `protobuf:"bytes,2,rep,name=jSONSchemas"` +} + +// JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. +// Defaults to true for the boolean property. +type JSONSchemaPropsOrBool struct { + Allows bool `protobuf:"varint,1,opt,name=allows"` + Schema *JSONSchemaProps `protobuf:"bytes,2,opt,name=schema"` +} + +// JSONSchemaDependencies represent a dependencies property. +type JSONSchemaDependencies map[string]JSONSchemaPropsOrStringArray + +// JSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array. +type JSONSchemaPropsOrStringArray struct { + Schema *JSONSchemaProps `protobuf:"bytes,1,opt,name=schema"` + Property []string `protobuf:"bytes,2,rep,name=property"` +} + +// JSONSchemaDefinitions contains the models explicitly defined in this spec. +type JSONSchemaDefinitions map[string]JSONSchemaProps + +// ExternalDocumentation allows referencing an external resource for extended documentation. +type ExternalDocumentation struct { + Description string `json:"description,omitempty" protobuf:"bytes,1,opt,name=description"` + URL string `json:"url,omitempty" protobuf:"bytes,2,opt,name=url"` +} From 64948dfc8003ec785216cc9a778e3bdac2bfc23a Mon Sep 17 00:00:00 2001 From: Nikhita Raghunath Date: Fri, 23 Jun 2017 01:10:12 +0530 Subject: [PATCH 2/6] Add generated code update generated proto --- .../src/k8s.io/api/core/v1/generated.pb.go | 1458 ++++---- .../src/k8s.io/api/core/v1/generated.proto | 1 + .../apiextensions/v1beta1/generated.pb.go | 3251 ++++++++++++++++- .../apiextensions/v1beta1/generated.proto | 122 + .../v1beta1/zz_generated.conversion.go | 615 +++- .../v1beta1/zz_generated.deepcopy.go | 193 + .../apiextensions/zz_generated.deepcopy.go | 168 + 7 files changed, 5022 insertions(+), 786 deletions(-) diff --git a/staging/src/k8s.io/api/core/v1/generated.pb.go b/staging/src/k8s.io/api/core/v1/generated.pb.go index 157ebb2269a..6cdd82fffea 100644 --- a/staging/src/k8s.io/api/core/v1/generated.pb.go +++ b/staging/src/k8s.io/api/core/v1/generated.pb.go @@ -45922,739 +45922,741 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 11739 bytes of a gzipped FileDescriptorProto + // 11768 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x5b, 0x90, 0x24, 0xc7, 0x71, 0x18, 0x7b, 0x66, 0x5f, 0x93, 0xfb, 0xae, 0xbb, 0x03, 0xe6, 0x16, 0xc0, 0xed, 0xa1, 0x41, 0x02, 0x87, 0xd7, 0x2e, 0x71, 0x00, 0x08, 0x88, 0x00, 0x41, 0xee, 0xee, 0xec, 0xde, 0x0d, 0xee, - 0x35, 0xa8, 0xd9, 0x3b, 0x08, 0x20, 0x04, 0xb1, 0x6f, 0xba, 0x76, 0xb7, 0xb1, 0xbd, 0xdd, 0x83, + 0x35, 0xa8, 0xd9, 0x3b, 0x08, 0x20, 0x04, 0xb1, 0x77, 0xba, 0x76, 0xb7, 0xb1, 0xbd, 0xdd, 0x83, 0xee, 0x9e, 0xbd, 0x5b, 0x84, 0x18, 0x61, 0xd3, 0x14, 0xfd, 0xa0, 0x3e, 0x14, 0x0e, 0x85, 0x2d, 0x8b, 0x0c, 0x39, 0xc2, 0x8f, 0x90, 0x68, 0xd9, 0x0e, 0xc9, 0x94, 0xf5, 0x20, 0xe5, 0xb0, 0x2c, - 0x3f, 0x82, 0xfc, 0xa1, 0x25, 0xff, 0x90, 0x11, 0x0e, 0xaf, 0xc4, 0xa5, 0xc3, 0x0e, 0x7d, 0xd8, + 0x3f, 0x82, 0xfc, 0xa1, 0x25, 0xff, 0x90, 0x11, 0x0e, 0xaf, 0xc4, 0xa3, 0xc3, 0x0e, 0x7d, 0xd8, 0x61, 0x5b, 0x5f, 0x5a, 0xcb, 0xa6, 0xa3, 0x9e, 0x5d, 0xd5, 0xd3, 0x3d, 0x33, 0x7b, 0xb8, 0x5b, 0x80, 0x0c, 0xff, 0xcd, 0x64, 0x66, 0x65, 0x55, 0xd7, 0x23, 0x2b, 0x2b, 0x2b, 0x33, 0x0b, 0x5e, - 0xda, 0x7e, 0x31, 0x5e, 0xf0, 0xc2, 0xc5, 0xed, 0xce, 0x4d, 0x12, 0x05, 0x24, 0x21, 0xf1, 0xe2, - 0x2e, 0x09, 0xdc, 0x30, 0x5a, 0x14, 0x08, 0xa7, 0xed, 0x2d, 0xb6, 0xc2, 0x88, 0x2c, 0xee, 0x3e, - 0xb3, 0xb8, 0x49, 0x02, 0x12, 0x39, 0x09, 0x71, 0x17, 0xda, 0x51, 0x98, 0x84, 0x08, 0x71, 0x9a, - 0x05, 0xa7, 0xed, 0x2d, 0x50, 0x9a, 0x85, 0xdd, 0x67, 0xe6, 0x9e, 0xde, 0xf4, 0x92, 0xad, 0xce, - 0xcd, 0x85, 0x56, 0xb8, 0xb3, 0xb8, 0x19, 0x6e, 0x86, 0x8b, 0x8c, 0xf4, 0x66, 0x67, 0x83, 0xfd, - 0x63, 0x7f, 0xd8, 0x2f, 0xce, 0x62, 0xee, 0xb9, 0xb4, 0x9a, 0x1d, 0xa7, 0xb5, 0xe5, 0x05, 0x24, - 0xda, 0x5b, 0x6c, 0x6f, 0x6f, 0xb2, 0x7a, 0x23, 0x12, 0x87, 0x9d, 0xa8, 0x45, 0xb2, 0x15, 0xf7, - 0x2c, 0x15, 0x2f, 0xee, 0x90, 0xc4, 0xc9, 0x69, 0xee, 0xdc, 0x62, 0x51, 0xa9, 0xa8, 0x13, 0x24, - 0xde, 0x4e, 0x77, 0x35, 0x9f, 0xe8, 0x57, 0x20, 0x6e, 0x6d, 0x91, 0x1d, 0xa7, 0xab, 0xdc, 0xb3, - 0x45, 0xe5, 0x3a, 0x89, 0xe7, 0x2f, 0x7a, 0x41, 0x12, 0x27, 0x51, 0xb6, 0x90, 0xfd, 0x5d, 0x0b, - 0xce, 0x2e, 0xbd, 0xde, 0x5c, 0xf5, 0x9d, 0x38, 0xf1, 0x5a, 0xcb, 0x7e, 0xd8, 0xda, 0x6e, 0x26, - 0x61, 0x44, 0x6e, 0x84, 0x7e, 0x67, 0x87, 0x34, 0x59, 0x47, 0xa0, 0xa7, 0x60, 0x6c, 0x97, 0xfd, - 0xaf, 0xd7, 0xaa, 0xd6, 0x59, 0xeb, 0x5c, 0x65, 0x79, 0xe6, 0x5b, 0xfb, 0xf3, 0x1f, 0x39, 0xd8, - 0x9f, 0x1f, 0xbb, 0x21, 0xe0, 0x58, 0x51, 0xa0, 0x47, 0x61, 0x64, 0x23, 0x5e, 0xdf, 0x6b, 0x93, - 0x6a, 0x89, 0xd1, 0x4e, 0x09, 0xda, 0x91, 0xb5, 0x26, 0x85, 0x62, 0x81, 0x45, 0x8b, 0x50, 0x69, - 0x3b, 0x51, 0xe2, 0x25, 0x5e, 0x18, 0x54, 0xcb, 0x67, 0xad, 0x73, 0xc3, 0xcb, 0xb3, 0x82, 0xb4, - 0xd2, 0x90, 0x08, 0x9c, 0xd2, 0xd0, 0x66, 0x44, 0xc4, 0x71, 0xaf, 0x05, 0xfe, 0x5e, 0x75, 0xe8, - 0xac, 0x75, 0x6e, 0x2c, 0x6d, 0x06, 0x16, 0x70, 0xac, 0x28, 0xec, 0x5f, 0x2a, 0xc1, 0xd8, 0xd2, - 0xc6, 0x86, 0x17, 0x78, 0xc9, 0x1e, 0xba, 0x01, 0x13, 0x41, 0xe8, 0x12, 0xf9, 0x9f, 0x7d, 0xc5, - 0xf8, 0xf9, 0xb3, 0x0b, 0xdd, 0x53, 0x69, 0xe1, 0xaa, 0x46, 0xb7, 0x3c, 0x73, 0xb0, 0x3f, 0x3f, - 0xa1, 0x43, 0xb0, 0xc1, 0x07, 0x61, 0x18, 0x6f, 0x87, 0xae, 0x62, 0x5b, 0x62, 0x6c, 0xe7, 0xf3, - 0xd8, 0x36, 0x52, 0xb2, 0xe5, 0xe9, 0x83, 0xfd, 0xf9, 0x71, 0x0d, 0x80, 0x75, 0x26, 0xe8, 0x26, - 0x4c, 0xd3, 0xbf, 0x41, 0xe2, 0x29, 0xbe, 0x65, 0xc6, 0xf7, 0x91, 0x22, 0xbe, 0x1a, 0xe9, 0xf2, - 0x89, 0x83, 0xfd, 0xf9, 0xe9, 0x0c, 0x10, 0x67, 0x19, 0xda, 0xef, 0xc1, 0xd4, 0x52, 0x92, 0x38, - 0xad, 0x2d, 0xe2, 0xf2, 0x11, 0x44, 0xcf, 0xc1, 0x50, 0xe0, 0xec, 0x10, 0x31, 0xbe, 0x67, 0x45, - 0xc7, 0x0e, 0x5d, 0x75, 0x76, 0xc8, 0xe1, 0xfe, 0xfc, 0xcc, 0xf5, 0xc0, 0x7b, 0xb7, 0x23, 0x66, - 0x05, 0x85, 0x61, 0x46, 0x8d, 0xce, 0x03, 0xb8, 0x64, 0xd7, 0x6b, 0x91, 0x86, 0x93, 0x6c, 0x89, - 0xf1, 0x46, 0xa2, 0x2c, 0xd4, 0x14, 0x06, 0x6b, 0x54, 0xf6, 0x6d, 0xa8, 0x2c, 0xed, 0x86, 0x9e, - 0xdb, 0x08, 0xdd, 0x18, 0x6d, 0xc3, 0x74, 0x3b, 0x22, 0x1b, 0x24, 0x52, 0xa0, 0xaa, 0x75, 0xb6, - 0x7c, 0x6e, 0xfc, 0xfc, 0xb9, 0xdc, 0x8f, 0x35, 0x49, 0x57, 0x83, 0x24, 0xda, 0x5b, 0xbe, 0x5f, - 0xd4, 0x37, 0x9d, 0xc1, 0xe2, 0x2c, 0x67, 0xfb, 0xdf, 0x94, 0xe0, 0xd4, 0xd2, 0x7b, 0x9d, 0x88, - 0xd4, 0xbc, 0x78, 0x3b, 0x3b, 0xc3, 0x5d, 0x2f, 0xde, 0xbe, 0x9a, 0xf6, 0x80, 0x9a, 0x5a, 0x35, - 0x01, 0xc7, 0x8a, 0x02, 0x3d, 0x0d, 0xa3, 0xf4, 0xf7, 0x75, 0x5c, 0x17, 0x9f, 0x7c, 0x42, 0x10, - 0x8f, 0xd7, 0x9c, 0xc4, 0xa9, 0x71, 0x14, 0x96, 0x34, 0xe8, 0x0a, 0x8c, 0xb7, 0xd8, 0x82, 0xdc, - 0xbc, 0x12, 0xba, 0x84, 0x0d, 0x66, 0x65, 0xf9, 0x49, 0x4a, 0xbe, 0x92, 0x82, 0x0f, 0xf7, 0xe7, - 0xab, 0xbc, 0x6d, 0x82, 0x85, 0x86, 0xc3, 0x7a, 0x79, 0x64, 0xab, 0xf5, 0x35, 0xc4, 0x38, 0x41, - 0xce, 0xda, 0x3a, 0xa7, 0x2d, 0x95, 0x61, 0xb6, 0x54, 0x26, 0xf2, 0x97, 0x09, 0x7a, 0x06, 0x86, - 0xb6, 0xbd, 0xc0, 0xad, 0x8e, 0x30, 0x5e, 0x0f, 0xd1, 0x31, 0xbf, 0xe4, 0x05, 0xee, 0xe1, 0xfe, - 0xfc, 0xac, 0xd1, 0x1c, 0x0a, 0xc4, 0x8c, 0xd4, 0xfe, 0x33, 0x0b, 0xe6, 0x19, 0x6e, 0xcd, 0xf3, - 0x49, 0x83, 0x44, 0xb1, 0x17, 0x27, 0x24, 0x48, 0x8c, 0x0e, 0x3d, 0x0f, 0x10, 0x93, 0x56, 0x44, - 0x12, 0xad, 0x4b, 0xd5, 0xc4, 0x68, 0x2a, 0x0c, 0xd6, 0xa8, 0xa8, 0x40, 0x88, 0xb7, 0x9c, 0x88, - 0xcd, 0x2f, 0xd1, 0xb1, 0x4a, 0x20, 0x34, 0x25, 0x02, 0xa7, 0x34, 0x86, 0x40, 0x28, 0xf7, 0x13, - 0x08, 0xe8, 0x53, 0x30, 0x9d, 0x56, 0x16, 0xb7, 0x9d, 0x96, 0xec, 0x40, 0xb6, 0x64, 0x9a, 0x26, - 0x0a, 0x67, 0x69, 0xed, 0x7f, 0x64, 0x89, 0xc9, 0x43, 0xbf, 0xfa, 0x43, 0xfe, 0xad, 0xf6, 0xef, - 0x58, 0x30, 0xba, 0xec, 0x05, 0xae, 0x17, 0x6c, 0xa2, 0xcf, 0xc1, 0x18, 0xdd, 0x9b, 0x5c, 0x27, - 0x71, 0x84, 0xdc, 0xfb, 0xb8, 0xb6, 0xb6, 0xd4, 0x56, 0xb1, 0xd0, 0xde, 0xde, 0xa4, 0x80, 0x78, - 0x81, 0x52, 0xd3, 0xd5, 0x76, 0xed, 0xe6, 0x3b, 0xa4, 0x95, 0x5c, 0x21, 0x89, 0x93, 0x7e, 0x4e, - 0x0a, 0xc3, 0x8a, 0x2b, 0xba, 0x04, 0x23, 0x89, 0x13, 0x6d, 0x92, 0x44, 0x08, 0xc0, 0x5c, 0x41, - 0xc5, 0x4b, 0x62, 0xba, 0x22, 0x49, 0xd0, 0x22, 0xe9, 0xb6, 0xb0, 0xce, 0x8a, 0x62, 0xc1, 0xc2, - 0x6e, 0xc1, 0xc4, 0x8a, 0xd3, 0x76, 0x6e, 0x7a, 0xbe, 0x97, 0x78, 0x24, 0x46, 0x8f, 0x41, 0xd9, - 0x71, 0x5d, 0x26, 0x15, 0x2a, 0xcb, 0xa7, 0x0e, 0xf6, 0xe7, 0xcb, 0x4b, 0x2e, 0x9d, 0x9e, 0xa0, - 0xa8, 0xf6, 0x30, 0xa5, 0x40, 0x4f, 0xc0, 0x90, 0x1b, 0x85, 0xed, 0x6a, 0x89, 0x51, 0xde, 0x47, - 0x67, 0x72, 0x2d, 0x0a, 0xdb, 0x19, 0x52, 0x46, 0x63, 0xff, 0x7e, 0x09, 0x1e, 0x5c, 0x21, 0xed, - 0xad, 0xb5, 0x66, 0xc1, 0xfc, 0x3d, 0x07, 0x63, 0x3b, 0x61, 0xe0, 0x25, 0x61, 0x14, 0x8b, 0xaa, - 0xd9, 0x02, 0xba, 0x22, 0x60, 0x58, 0x61, 0xd1, 0x59, 0x18, 0x6a, 0xa7, 0xc2, 0x6f, 0x42, 0x0a, - 0x4e, 0x26, 0xf6, 0x18, 0x86, 0x52, 0x74, 0x62, 0x12, 0x89, 0x85, 0xaf, 0x28, 0xae, 0xc7, 0x24, - 0xc2, 0x0c, 0x93, 0xce, 0x20, 0x3a, 0xb7, 0xc4, 0xac, 0xcc, 0xcc, 0x20, 0x8a, 0xc1, 0x1a, 0x15, - 0x6a, 0x40, 0x85, 0xff, 0xc3, 0x64, 0x83, 0xad, 0xf1, 0x82, 0x7e, 0x6f, 0x4a, 0x22, 0xd1, 0xef, - 0x93, 0x6c, 0x8a, 0x49, 0x20, 0x4e, 0x99, 0x18, 0x53, 0x6c, 0xa4, 0xef, 0x14, 0xfb, 0x66, 0x09, - 0x10, 0xef, 0xc2, 0x1f, 0xb1, 0x8e, 0xbb, 0xde, 0xdd, 0x71, 0xb9, 0x9b, 0xcd, 0xe5, 0xb0, 0xe5, - 0xf8, 0xd9, 0x59, 0x7b, 0xb7, 0x7a, 0xef, 0x17, 0x2d, 0x40, 0x2b, 0x5e, 0xe0, 0x92, 0xe8, 0x18, - 0x34, 0xad, 0xa3, 0xc9, 0x8e, 0xcb, 0x30, 0xb5, 0xe2, 0x7b, 0x24, 0x48, 0xea, 0x8d, 0x95, 0x30, - 0xd8, 0xf0, 0x36, 0xd1, 0x27, 0x61, 0x8a, 0x2a, 0x9e, 0x61, 0x27, 0x69, 0x92, 0x56, 0x18, 0xb0, - 0x3d, 0x9a, 0xaa, 0x6b, 0xe8, 0x60, 0x7f, 0x7e, 0x6a, 0xdd, 0xc0, 0xe0, 0x0c, 0xa5, 0xfd, 0x1f, - 0xe9, 0x87, 0x86, 0x3b, 0xed, 0x30, 0x20, 0x41, 0xb2, 0x12, 0x06, 0x2e, 0xd7, 0xe5, 0x3e, 0x09, - 0x43, 0x09, 0x6d, 0x38, 0xff, 0xc8, 0x47, 0xe5, 0xd0, 0xd2, 0xe6, 0x1e, 0xee, 0xcf, 0xdf, 0xd7, - 0x5d, 0x82, 0x7d, 0x10, 0x2b, 0x83, 0x7e, 0x02, 0x46, 0xe2, 0xc4, 0x49, 0x3a, 0xb1, 0xf8, 0xec, - 0x87, 0xe5, 0x67, 0x37, 0x19, 0xf4, 0x70, 0x7f, 0x7e, 0x5a, 0x15, 0xe3, 0x20, 0x2c, 0x0a, 0xa0, - 0xc7, 0x61, 0x74, 0x87, 0xc4, 0xb1, 0xb3, 0x29, 0xb7, 0xe1, 0x69, 0x51, 0x76, 0xf4, 0x0a, 0x07, - 0x63, 0x89, 0x47, 0x8f, 0xc0, 0x30, 0x89, 0xa2, 0x30, 0x12, 0xb3, 0x6a, 0x52, 0x10, 0x0e, 0xaf, - 0x52, 0x20, 0xe6, 0x38, 0xfb, 0xdf, 0x5b, 0x30, 0xad, 0xda, 0xca, 0xeb, 0x3a, 0x06, 0x79, 0xfb, - 0x26, 0x40, 0x4b, 0x7e, 0x60, 0xcc, 0xe4, 0xdd, 0xf8, 0xf9, 0x47, 0xf3, 0xa6, 0x70, 0x77, 0x37, - 0xa6, 0x9c, 0x15, 0x28, 0xc6, 0x1a, 0x37, 0xfb, 0x5f, 0x58, 0x70, 0x22, 0xf3, 0x45, 0x97, 0xbd, - 0x38, 0x41, 0x6f, 0x75, 0x7d, 0xd5, 0xc2, 0x60, 0x5f, 0x45, 0x4b, 0xb3, 0x6f, 0x52, 0x73, 0x4e, - 0x42, 0xb4, 0x2f, 0xba, 0x08, 0xc3, 0x5e, 0x42, 0x76, 0xe4, 0xc7, 0x3c, 0xd2, 0xf3, 0x63, 0x78, - 0xab, 0xd2, 0x11, 0xa9, 0xd3, 0x92, 0x98, 0x33, 0xb0, 0xff, 0xa7, 0x05, 0x15, 0x3e, 0x6d, 0xaf, - 0x38, 0xed, 0x63, 0x18, 0x8b, 0x3a, 0x0c, 0x31, 0xee, 0xbc, 0xe1, 0x8f, 0xe5, 0x37, 0x5c, 0x34, - 0x67, 0x81, 0x2a, 0x53, 0x5c, 0x69, 0x55, 0xc2, 0x8c, 0x82, 0x30, 0x63, 0x31, 0xf7, 0x02, 0x54, - 0x14, 0x01, 0x9a, 0x81, 0xf2, 0x36, 0xe1, 0x07, 0x95, 0x0a, 0xa6, 0x3f, 0xd1, 0x49, 0x18, 0xde, - 0x75, 0xfc, 0x8e, 0x58, 0xec, 0x98, 0xff, 0xf9, 0x64, 0xe9, 0x45, 0xcb, 0xfe, 0x06, 0x5b, 0x63, - 0xa2, 0x92, 0xd5, 0x60, 0x57, 0x08, 0x93, 0xf7, 0xe0, 0xa4, 0x9f, 0x23, 0xc3, 0x44, 0x47, 0x0c, - 0x2e, 0xf3, 0x1e, 0x14, 0x6d, 0x3d, 0x99, 0x87, 0xc5, 0xb9, 0x75, 0xd0, 0x6d, 0x20, 0x6c, 0xd3, - 0x19, 0xe5, 0xf8, 0xac, 0xbd, 0x42, 0x01, 0xbd, 0x26, 0x60, 0x58, 0x61, 0xa9, 0x80, 0x38, 0xa9, - 0x1a, 0x7f, 0x89, 0xec, 0x35, 0x89, 0x4f, 0x5a, 0x49, 0x18, 0x7d, 0xa0, 0xcd, 0x7f, 0x88, 0xf7, - 0x3e, 0x97, 0x2f, 0xe3, 0x82, 0x41, 0xf9, 0x12, 0xd9, 0xe3, 0x43, 0xa1, 0x7f, 0x5d, 0xb9, 0xe7, - 0xd7, 0xfd, 0x86, 0x05, 0x93, 0xea, 0xeb, 0x8e, 0x61, 0x21, 0x2d, 0x9b, 0x0b, 0xe9, 0xa1, 0x9e, - 0xf3, 0xb1, 0x60, 0x09, 0xfd, 0x90, 0x89, 0x00, 0x41, 0xd3, 0x88, 0x42, 0xda, 0x35, 0x54, 0x66, - 0x7f, 0x90, 0x03, 0x32, 0xc8, 0x77, 0x5d, 0x22, 0x7b, 0xeb, 0x21, 0x55, 0x1f, 0xf2, 0xbf, 0xcb, - 0x18, 0xb5, 0xa1, 0x9e, 0xa3, 0xf6, 0x9b, 0x25, 0x38, 0xa5, 0x7a, 0xc0, 0xd8, 0xa0, 0x7f, 0xd4, - 0xfb, 0xe0, 0x19, 0x18, 0x77, 0xc9, 0x86, 0xd3, 0xf1, 0x13, 0x75, 0x16, 0x1d, 0xe6, 0xf6, 0x88, - 0x5a, 0x0a, 0xc6, 0x3a, 0xcd, 0x11, 0xba, 0xed, 0xdf, 0x02, 0x93, 0xbd, 0x89, 0x43, 0x67, 0x30, - 0xd5, 0xde, 0x34, 0x8b, 0xc2, 0x84, 0x6e, 0x51, 0x10, 0xd6, 0x83, 0x47, 0x60, 0xd8, 0xdb, 0xa1, - 0x7b, 0x71, 0xc9, 0xdc, 0x62, 0xeb, 0x14, 0x88, 0x39, 0x0e, 0x7d, 0x0c, 0x46, 0x5b, 0xe1, 0xce, - 0x8e, 0x13, 0xb8, 0xd5, 0x32, 0xd3, 0x27, 0xc7, 0xe9, 0x76, 0xbd, 0xc2, 0x41, 0x58, 0xe2, 0xd0, - 0x83, 0x30, 0xe4, 0x44, 0x9b, 0x71, 0x75, 0x88, 0xd1, 0x8c, 0xd1, 0x9a, 0x96, 0xa2, 0xcd, 0x18, - 0x33, 0x28, 0xd5, 0x13, 0x6f, 0x85, 0xd1, 0xb6, 0x17, 0x6c, 0xd6, 0xbc, 0x88, 0x29, 0x7d, 0x9a, - 0x9e, 0xf8, 0xba, 0xc2, 0x60, 0x8d, 0x0a, 0xad, 0xc1, 0x70, 0x3b, 0x8c, 0x92, 0xb8, 0x3a, 0xc2, - 0xba, 0xfb, 0xe1, 0x82, 0xa5, 0xc4, 0xbf, 0xb6, 0x11, 0x46, 0x49, 0xfa, 0x01, 0xf4, 0x5f, 0x8c, - 0x79, 0x71, 0xf4, 0x13, 0x50, 0x26, 0xc1, 0x6e, 0x75, 0x94, 0x71, 0x99, 0xcb, 0xe3, 0xb2, 0x1a, - 0xec, 0xde, 0x70, 0xa2, 0x54, 0xce, 0xac, 0x06, 0xbb, 0x98, 0x96, 0x41, 0x6f, 0x40, 0x45, 0x5a, - 0x23, 0xe3, 0xea, 0x58, 0xf1, 0x14, 0xc3, 0x82, 0x08, 0x93, 0x77, 0x3b, 0x5e, 0x44, 0x76, 0x48, - 0x90, 0xc4, 0xe9, 0x79, 0x52, 0x62, 0x63, 0x9c, 0x72, 0x43, 0x6f, 0xc0, 0x04, 0xd7, 0x23, 0xaf, - 0x84, 0x9d, 0x20, 0x89, 0xab, 0x15, 0xd6, 0xbc, 0x5c, 0xd3, 0xd5, 0x8d, 0x94, 0x6e, 0xf9, 0xa4, - 0x60, 0x3a, 0xa1, 0x01, 0x63, 0x6c, 0xb0, 0x42, 0x18, 0x26, 0x7d, 0x6f, 0x97, 0x04, 0x24, 0x8e, - 0x1b, 0x51, 0x78, 0x93, 0x54, 0x81, 0xb5, 0xfc, 0x74, 0xbe, 0x45, 0x27, 0xbc, 0x49, 0x96, 0x67, - 0x0f, 0xf6, 0xe7, 0x27, 0x2f, 0xeb, 0x65, 0xb0, 0xc9, 0x02, 0x5d, 0x87, 0x29, 0xaa, 0xa0, 0x7a, - 0x29, 0xd3, 0xf1, 0x7e, 0x4c, 0x99, 0x76, 0x8a, 0x8d, 0x42, 0x38, 0xc3, 0x04, 0xbd, 0x0a, 0x15, - 0xdf, 0xdb, 0x20, 0xad, 0xbd, 0x96, 0x4f, 0xaa, 0x13, 0x8c, 0x63, 0xee, 0xb2, 0xba, 0x2c, 0x89, - 0xf8, 0x01, 0x40, 0xfd, 0xc5, 0x69, 0x71, 0x74, 0x03, 0xee, 0x4b, 0x48, 0xb4, 0xe3, 0x05, 0x0e, - 0x5d, 0x0e, 0x42, 0x9f, 0x64, 0x76, 0xb1, 0x49, 0x36, 0xdf, 0xce, 0x88, 0xae, 0xbb, 0x6f, 0x3d, - 0x97, 0x0a, 0x17, 0x94, 0x46, 0xd7, 0x60, 0x9a, 0xad, 0x84, 0x46, 0xc7, 0xf7, 0x1b, 0xa1, 0xef, - 0xb5, 0xf6, 0xaa, 0x53, 0x8c, 0xe1, 0xc7, 0xa4, 0xe1, 0xab, 0x6e, 0xa2, 0xe9, 0x89, 0x37, 0xfd, - 0x87, 0xb3, 0xa5, 0xd1, 0x4d, 0x66, 0x08, 0xe9, 0x44, 0x5e, 0xb2, 0x47, 0xe7, 0x2f, 0xb9, 0x9d, - 0x54, 0xa7, 0x7b, 0x9e, 0x1f, 0x75, 0x52, 0x65, 0x2d, 0xd1, 0x81, 0x38, 0xcb, 0x90, 0x2e, 0xed, - 0x38, 0x71, 0xbd, 0xa0, 0x3a, 0xc3, 0x24, 0x86, 0x5a, 0x19, 0x4d, 0x0a, 0xc4, 0x1c, 0xc7, 0x8c, - 0x20, 0xf4, 0xc7, 0x35, 0x2a, 0x41, 0x67, 0x19, 0x61, 0x6a, 0x04, 0x91, 0x08, 0x9c, 0xd2, 0xd0, - 0x6d, 0x39, 0x49, 0xf6, 0xaa, 0x88, 0x91, 0xaa, 0xe5, 0xb2, 0xbe, 0xfe, 0x06, 0xa6, 0x70, 0x74, - 0x19, 0x46, 0x49, 0xb0, 0xbb, 0x16, 0x85, 0x3b, 0xd5, 0x13, 0xc5, 0x6b, 0x76, 0x95, 0x93, 0x70, - 0x81, 0x9e, 0x1e, 0x00, 0x04, 0x18, 0x4b, 0x16, 0xe8, 0x36, 0x54, 0x73, 0x46, 0x84, 0x0f, 0xc0, - 0x49, 0x36, 0x00, 0x2f, 0x8b, 0xb2, 0xd5, 0xf5, 0x02, 0xba, 0xc3, 0x1e, 0x38, 0x5c, 0xc8, 0xdd, - 0xbe, 0x09, 0x53, 0x4a, 0xb0, 0xb0, 0xb1, 0x45, 0xf3, 0x30, 0x4c, 0x25, 0xa6, 0x3c, 0x52, 0x57, - 0x68, 0x57, 0x32, 0xd3, 0x14, 0xe6, 0x70, 0xd6, 0x95, 0xde, 0x7b, 0x64, 0x79, 0x2f, 0x21, 0xfc, - 0x58, 0x54, 0xd6, 0xba, 0x52, 0x22, 0x70, 0x4a, 0x63, 0xff, 0x5f, 0xae, 0x98, 0xa4, 0xd2, 0x6b, - 0x00, 0x79, 0xfd, 0x14, 0x8c, 0x6d, 0x85, 0x71, 0x42, 0xa9, 0x59, 0x1d, 0xc3, 0xa9, 0x2a, 0x72, - 0x51, 0xc0, 0xb1, 0xa2, 0x40, 0x2f, 0xc1, 0x64, 0x4b, 0xaf, 0x40, 0x6c, 0x36, 0xa7, 0x44, 0x11, - 0xb3, 0x76, 0x6c, 0xd2, 0xa2, 0x17, 0x61, 0x8c, 0x5d, 0x50, 0xb4, 0x42, 0x5f, 0x1c, 0xc0, 0xe4, - 0x8e, 0x39, 0xd6, 0x10, 0xf0, 0x43, 0xed, 0x37, 0x56, 0xd4, 0xf4, 0x50, 0x4c, 0x9b, 0x50, 0x6f, - 0x08, 0x31, 0xaf, 0x0e, 0xc5, 0x17, 0x19, 0x14, 0x0b, 0xac, 0xfd, 0x37, 0x4b, 0x5a, 0x2f, 0xd3, - 0x23, 0x05, 0x41, 0x0d, 0x18, 0xbd, 0xe5, 0x78, 0x89, 0x17, 0x6c, 0x8a, 0xfd, 0xfc, 0xf1, 0x9e, - 0x32, 0x9f, 0x15, 0x7a, 0x9d, 0x17, 0xe0, 0xbb, 0x92, 0xf8, 0x83, 0x25, 0x1b, 0xca, 0x31, 0xea, - 0x04, 0x01, 0xe5, 0x58, 0x1a, 0x94, 0x23, 0xe6, 0x05, 0x38, 0x47, 0xf1, 0x07, 0x4b, 0x36, 0xe8, - 0x2d, 0x00, 0x39, 0x6f, 0x88, 0x2b, 0x2e, 0x06, 0x9e, 0xea, 0xcf, 0x74, 0x5d, 0x95, 0x59, 0x9e, - 0xa2, 0x7b, 0x5e, 0xfa, 0x1f, 0x6b, 0xfc, 0xec, 0x84, 0xe9, 0x3d, 0xdd, 0x8d, 0x41, 0x9f, 0xa5, - 0x4b, 0xd5, 0x89, 0x12, 0xe2, 0x2e, 0x25, 0xa2, 0x73, 0x9e, 0x18, 0x4c, 0x6d, 0x5d, 0xf7, 0x76, - 0x88, 0xbe, 0xac, 0x05, 0x13, 0x9c, 0xf2, 0xb3, 0x7f, 0xbb, 0x0c, 0xd5, 0xa2, 0xe6, 0xd2, 0x49, - 0x47, 0x6e, 0x7b, 0xc9, 0x0a, 0x55, 0x57, 0x2c, 0x73, 0xd2, 0xad, 0x0a, 0x38, 0x56, 0x14, 0x74, - 0xf4, 0x63, 0x6f, 0x53, 0x9e, 0x3a, 0x86, 0xd3, 0xd1, 0x6f, 0x32, 0x28, 0x16, 0x58, 0x4a, 0x17, - 0x11, 0x27, 0x16, 0x37, 0x4f, 0xda, 0x2c, 0xc1, 0x0c, 0x8a, 0x05, 0x56, 0x37, 0x18, 0x0c, 0xf5, - 0x31, 0x18, 0x18, 0x5d, 0x34, 0x7c, 0x77, 0xbb, 0x08, 0xbd, 0x0d, 0xb0, 0xe1, 0x05, 0x5e, 0xbc, - 0xc5, 0xb8, 0x8f, 0x1c, 0x99, 0xbb, 0x52, 0x76, 0xd6, 0x14, 0x17, 0xac, 0x71, 0x44, 0xcf, 0xc3, - 0xb8, 0x5a, 0x80, 0xf5, 0x5a, 0x75, 0xd4, 0xbc, 0xd6, 0x48, 0xa5, 0x51, 0x0d, 0xeb, 0x74, 0xf6, - 0x3b, 0xd9, 0xf9, 0x22, 0x56, 0x80, 0xd6, 0xbf, 0xd6, 0xa0, 0xfd, 0x5b, 0xea, 0xdd, 0xbf, 0xf6, - 0x1f, 0x94, 0x61, 0xda, 0xa8, 0xac, 0x13, 0x0f, 0x20, 0xb3, 0x2e, 0xd0, 0x8d, 0xc8, 0x49, 0x88, - 0x58, 0x7f, 0x76, 0xff, 0xa5, 0xa2, 0x6f, 0x56, 0x74, 0x05, 0xf0, 0xf2, 0xe8, 0x6d, 0xa8, 0xf8, - 0x4e, 0xcc, 0x8c, 0x0f, 0x44, 0xac, 0xbb, 0x41, 0x98, 0xa5, 0x8a, 0xbe, 0x13, 0x27, 0xda, 0x5e, - 0xc0, 0x79, 0xa7, 0x2c, 0xe9, 0x8e, 0x49, 0x95, 0x13, 0x79, 0xb5, 0xa9, 0x1a, 0x41, 0x35, 0x98, - 0x3d, 0xcc, 0x71, 0xe8, 0x45, 0x98, 0x88, 0x08, 0x9b, 0x15, 0x2b, 0x54, 0xd7, 0x62, 0xd3, 0x6c, - 0x38, 0x55, 0xca, 0xb0, 0x86, 0xc3, 0x06, 0x65, 0xaa, 0x6b, 0x8f, 0xf4, 0xd0, 0xb5, 0x1f, 0x87, - 0x51, 0xf6, 0x43, 0xcd, 0x00, 0x35, 0x1a, 0x75, 0x0e, 0xc6, 0x12, 0x9f, 0x9d, 0x30, 0x63, 0x03, - 0x4e, 0x98, 0x27, 0x60, 0xaa, 0xe6, 0x90, 0x9d, 0x30, 0x58, 0x0d, 0xdc, 0x76, 0xe8, 0x05, 0x09, - 0xaa, 0xc2, 0x10, 0xdb, 0x1d, 0xf8, 0xda, 0x1e, 0xa2, 0x1c, 0xf0, 0x10, 0xd5, 0x9c, 0xed, 0x3f, - 0x2a, 0xc1, 0x64, 0x8d, 0xf8, 0x24, 0x21, 0xfc, 0xac, 0x11, 0xa3, 0x35, 0x40, 0x9b, 0x91, 0xd3, - 0x22, 0x0d, 0x12, 0x79, 0xa1, 0xab, 0x1b, 0x23, 0xcb, 0xcc, 0xe0, 0x8f, 0x2e, 0x74, 0x61, 0x71, - 0x4e, 0x09, 0xf4, 0x26, 0x4c, 0xb6, 0x23, 0x62, 0xd8, 0xd0, 0xac, 0x22, 0x75, 0xa1, 0xa1, 0x13, - 0x72, 0x4d, 0xd5, 0x00, 0x61, 0x93, 0x15, 0xfa, 0x0c, 0xcc, 0x84, 0x51, 0x7b, 0xcb, 0x09, 0x6a, - 0xa4, 0x4d, 0x02, 0x97, 0xaa, 0xe2, 0xc2, 0x46, 0x70, 0xf2, 0x60, 0x7f, 0x7e, 0xe6, 0x5a, 0x06, - 0x87, 0xbb, 0xa8, 0xd1, 0x9b, 0x30, 0xdb, 0x8e, 0xc2, 0xb6, 0xb3, 0xc9, 0x26, 0x8a, 0xd0, 0x38, - 0xb8, 0xf4, 0x79, 0xea, 0x60, 0x7f, 0x7e, 0xb6, 0x91, 0x45, 0x1e, 0xee, 0xcf, 0x9f, 0x60, 0x1d, - 0x45, 0x21, 0x29, 0x12, 0x77, 0xb3, 0xb1, 0x37, 0xe1, 0x54, 0x2d, 0xbc, 0x15, 0xdc, 0x72, 0x22, - 0x77, 0xa9, 0x51, 0xd7, 0x0e, 0xf7, 0x57, 0xe5, 0xe1, 0x92, 0x5f, 0xbf, 0xe6, 0xee, 0x53, 0x5a, - 0x49, 0xae, 0xfe, 0xaf, 0x79, 0x3e, 0x29, 0x30, 0x22, 0xfc, 0xed, 0x92, 0x51, 0x53, 0x4a, 0xaf, - 0xec, 0xfe, 0x56, 0xa1, 0xdd, 0xff, 0x35, 0x18, 0xdb, 0xf0, 0x88, 0xef, 0x62, 0xb2, 0x21, 0x46, - 0xe6, 0xb1, 0xe2, 0x1b, 0xa5, 0x35, 0x4a, 0x29, 0x8d, 0x46, 0xfc, 0x68, 0xba, 0x26, 0x0a, 0x63, - 0xc5, 0x06, 0x6d, 0xc3, 0x8c, 0x3c, 0xfb, 0x48, 0xac, 0x58, 0xc4, 0x8f, 0xf7, 0x3a, 0x50, 0x99, - 0xcc, 0xd9, 0x00, 0xe2, 0x0c, 0x1b, 0xdc, 0xc5, 0x98, 0x9e, 0x45, 0x77, 0xe8, 0x76, 0x35, 0xc4, - 0xa6, 0x34, 0x3b, 0x8b, 0xb2, 0x63, 0x35, 0x83, 0xda, 0x5f, 0xb5, 0xe0, 0xfe, 0xae, 0x9e, 0x11, - 0xe6, 0x85, 0xbb, 0x3c, 0x0a, 0xd9, 0xe3, 0x7e, 0xa9, 0xff, 0x71, 0xdf, 0xfe, 0x75, 0x0b, 0x4e, - 0xae, 0xee, 0xb4, 0x93, 0xbd, 0x9a, 0x67, 0xde, 0x4d, 0xbc, 0x00, 0x23, 0x3b, 0xc4, 0xf5, 0x3a, - 0x3b, 0x62, 0xe4, 0xe6, 0xa5, 0x48, 0xbf, 0xc2, 0xa0, 0x87, 0xfb, 0xf3, 0x93, 0xcd, 0x24, 0x8c, - 0x9c, 0x4d, 0xc2, 0x01, 0x58, 0x90, 0xa3, 0x9f, 0xe6, 0xba, 0xe9, 0x65, 0x6f, 0xc7, 0x93, 0x37, - 0x84, 0x3d, 0x4d, 0x5e, 0x0b, 0xb2, 0x43, 0x17, 0x5e, 0xeb, 0x38, 0x41, 0xe2, 0x25, 0x7b, 0xa6, - 0x2e, 0xcb, 0x18, 0xe1, 0x94, 0xa7, 0xfd, 0x5d, 0x0b, 0xa6, 0xa5, 0x3c, 0x59, 0x72, 0xdd, 0x88, - 0xc4, 0x31, 0x9a, 0x83, 0x92, 0xd7, 0x16, 0x2d, 0x05, 0x51, 0xba, 0x54, 0x6f, 0xe0, 0x92, 0xd7, - 0x46, 0x0d, 0xa8, 0xf0, 0xcb, 0xc6, 0x74, 0x82, 0x0d, 0x74, 0x65, 0xc9, 0xce, 0x7e, 0xeb, 0xb2, - 0x24, 0x4e, 0x99, 0x48, 0xcd, 0x98, 0xed, 0x45, 0x65, 0xf3, 0xde, 0xe6, 0xa2, 0x80, 0x63, 0x45, - 0x81, 0xce, 0xc1, 0x58, 0x10, 0xba, 0xfc, 0xee, 0x97, 0xaf, 0x6b, 0x36, 0x6d, 0xaf, 0x0a, 0x18, - 0x56, 0x58, 0xfb, 0xe7, 0x2c, 0x98, 0x90, 0x5f, 0x36, 0xa0, 0x92, 0x4e, 0x97, 0x57, 0xaa, 0xa0, - 0xa7, 0xcb, 0x8b, 0x2a, 0xd9, 0x0c, 0x63, 0xe8, 0xd6, 0xe5, 0xa3, 0xe8, 0xd6, 0xf6, 0x57, 0x4a, - 0x30, 0x25, 0x9b, 0xd3, 0xec, 0xdc, 0x8c, 0x49, 0x82, 0xd6, 0xa1, 0xe2, 0xf0, 0x2e, 0x27, 0x72, - 0xd6, 0x3e, 0x92, 0x7f, 0xea, 0x32, 0xc6, 0x27, 0x1d, 0xd1, 0x25, 0x59, 0x1a, 0xa7, 0x8c, 0x90, - 0x0f, 0xb3, 0x41, 0x98, 0xb0, 0xad, 0x4f, 0xe1, 0x7b, 0xdd, 0x0d, 0x64, 0xb9, 0x9f, 0x16, 0xdc, - 0x67, 0xaf, 0x66, 0xb9, 0xe0, 0x6e, 0xc6, 0x68, 0x55, 0x5a, 0x7a, 0xca, 0xac, 0x86, 0xb3, 0xbd, - 0x6a, 0x28, 0x36, 0xf4, 0xd8, 0xbf, 0x67, 0x41, 0x45, 0x92, 0x1d, 0xc7, 0x35, 0xd0, 0x15, 0x18, - 0x8d, 0xd9, 0x20, 0xc8, 0xae, 0xb1, 0x7b, 0x35, 0x9c, 0x8f, 0x57, 0xba, 0xa3, 0xf3, 0xff, 0x31, - 0x96, 0x3c, 0x98, 0xa9, 0x5a, 0x35, 0xff, 0x43, 0x62, 0xaa, 0x56, 0xed, 0x29, 0xd8, 0x65, 0xfe, - 0x2b, 0x6b, 0xb3, 0x76, 0x9e, 0xa7, 0x8a, 0x67, 0x3b, 0x22, 0x1b, 0xde, 0xed, 0xac, 0xe2, 0xd9, - 0x60, 0x50, 0x2c, 0xb0, 0xe8, 0x2d, 0x98, 0x68, 0x49, 0x0b, 0x6f, 0x2a, 0x06, 0x1e, 0xed, 0x69, - 0x2f, 0x57, 0x57, 0x2b, 0xdc, 0x2f, 0x6c, 0x45, 0x2b, 0x8f, 0x0d, 0x6e, 0xe6, 0xe5, 0x7c, 0xb9, - 0xdf, 0xe5, 0x7c, 0xca, 0xb7, 0xf0, 0x7a, 0xd9, 0xfe, 0x65, 0x0b, 0x46, 0xb8, 0x9d, 0x70, 0x30, - 0xc3, 0xaa, 0x76, 0x55, 0x94, 0xf6, 0xdd, 0x0d, 0x0a, 0x14, 0x37, 0x47, 0xe8, 0x0a, 0x54, 0xd8, - 0x0f, 0x66, 0x2f, 0x29, 0x17, 0x3b, 0xc4, 0xf1, 0x5a, 0xf5, 0x06, 0xde, 0x90, 0xc5, 0x70, 0xca, - 0xc1, 0xfe, 0x85, 0x32, 0x15, 0x55, 0x29, 0xa9, 0xb1, 0x8b, 0x5b, 0xf7, 0x6e, 0x17, 0x2f, 0xdd, - 0xab, 0x5d, 0x7c, 0x13, 0xa6, 0x5b, 0xda, 0xbd, 0x54, 0x3a, 0x92, 0xe7, 0x7a, 0x4e, 0x12, 0xed, - 0x0a, 0x8b, 0xdb, 0xca, 0x56, 0x4c, 0x26, 0x38, 0xcb, 0x15, 0x7d, 0x16, 0x26, 0xf8, 0x38, 0x8b, - 0x5a, 0x86, 0x58, 0x2d, 0x1f, 0x2b, 0x9e, 0x2f, 0x7a, 0x15, 0x6c, 0x26, 0x36, 0xb5, 0xe2, 0xd8, - 0x60, 0x66, 0x7f, 0x69, 0x18, 0x86, 0x57, 0x77, 0x49, 0x90, 0x1c, 0x83, 0x40, 0x6a, 0xc1, 0x94, - 0x17, 0xec, 0x86, 0xfe, 0x2e, 0x71, 0x39, 0xfe, 0x28, 0x9b, 0xeb, 0x7d, 0x82, 0xf5, 0x54, 0xdd, - 0x60, 0x81, 0x33, 0x2c, 0xef, 0xc5, 0xc9, 0xfd, 0x02, 0x8c, 0xf0, 0xb1, 0x17, 0xc7, 0xf6, 0x5c, - 0x2b, 0x38, 0xeb, 0x44, 0xb1, 0x0a, 0x52, 0xab, 0x02, 0x37, 0xbb, 0x8b, 0xe2, 0xe8, 0x1d, 0x98, - 0xda, 0xf0, 0xa2, 0x38, 0xa1, 0x47, 0xee, 0x38, 0x71, 0x76, 0xda, 0x77, 0x70, 0x52, 0x57, 0xfd, - 0xb0, 0x66, 0x70, 0xc2, 0x19, 0xce, 0x68, 0x13, 0x26, 0xe9, 0xe1, 0x31, 0xad, 0x6a, 0xf4, 0xc8, - 0x55, 0x29, 0x53, 0xdc, 0x65, 0x9d, 0x11, 0x36, 0xf9, 0x52, 0x61, 0xd2, 0x62, 0x87, 0xcd, 0x31, - 0xa6, 0x51, 0x28, 0x61, 0xc2, 0x4f, 0x99, 0x1c, 0x47, 0x65, 0x12, 0xf3, 0xe7, 0xa8, 0x98, 0x32, - 0x29, 0xf5, 0xda, 0xb0, 0xbf, 0x46, 0x77, 0x47, 0xda, 0x87, 0xc7, 0xb0, 0xb5, 0xbc, 0x62, 0x6e, - 0x2d, 0xa7, 0x0b, 0xc7, 0xb3, 0x60, 0x5b, 0xf9, 0x1c, 0x8c, 0x6b, 0xc3, 0x8d, 0x16, 0xa1, 0xd2, - 0x92, 0xce, 0x07, 0x42, 0xea, 0x2a, 0xf5, 0x45, 0x79, 0x25, 0xe0, 0x94, 0x86, 0xf6, 0x06, 0x55, - 0xf6, 0xb2, 0xae, 0x4d, 0x54, 0x15, 0xc4, 0x0c, 0x63, 0x3f, 0x0b, 0xb0, 0x7a, 0x9b, 0xb4, 0x96, - 0xf8, 0xe1, 0x4b, 0xbb, 0xe3, 0xb2, 0x8a, 0xef, 0xb8, 0xec, 0xff, 0x60, 0xc1, 0xd4, 0xda, 0x8a, - 0xa1, 0x94, 0x2f, 0x00, 0x70, 0x2d, 0xf4, 0xf5, 0xd7, 0xaf, 0x4a, 0xeb, 0x30, 0x37, 0xf0, 0x29, - 0x28, 0xd6, 0x28, 0xd0, 0x69, 0x28, 0xfb, 0x9d, 0x40, 0x28, 0x87, 0xa3, 0x07, 0xfb, 0xf3, 0xe5, - 0xcb, 0x9d, 0x00, 0x53, 0x98, 0xe6, 0x4d, 0x54, 0x1e, 0xd8, 0x9b, 0xa8, 0xaf, 0x1b, 0x36, 0x9a, - 0x87, 0xe1, 0x5b, 0xb7, 0x3c, 0x37, 0xae, 0x0e, 0xa7, 0x96, 0xeb, 0xd7, 0x5f, 0xaf, 0xd7, 0x62, - 0xcc, 0xe1, 0xf6, 0x5f, 0x2e, 0xc3, 0xcc, 0x9a, 0x4f, 0x6e, 0x1b, 0x9f, 0xf5, 0x28, 0x8c, 0xb8, - 0x91, 0xb7, 0x4b, 0xa2, 0xec, 0x2e, 0x5e, 0x63, 0x50, 0x2c, 0xb0, 0x03, 0x7b, 0x40, 0x5d, 0xef, - 0xde, 0x8f, 0xef, 0xb6, 0xcf, 0x57, 0xff, 0xae, 0x78, 0x0b, 0x46, 0xf9, 0x55, 0x29, 0xef, 0x8c, - 0xf1, 0xf3, 0xcf, 0xe4, 0x35, 0x21, 0xdb, 0x17, 0x0b, 0xc2, 0xf8, 0xc1, 0xfd, 0x46, 0x94, 0x10, - 0x13, 0x50, 0x2c, 0x59, 0xce, 0x7d, 0x12, 0x26, 0x74, 0xca, 0x23, 0x39, 0x90, 0xfc, 0x15, 0x0b, - 0x4e, 0xac, 0xf9, 0x61, 0x6b, 0x3b, 0xe3, 0x8e, 0xf6, 0x3c, 0x8c, 0xd3, 0xf5, 0x14, 0x1b, 0xae, - 0xad, 0x86, 0xb3, 0xb3, 0x40, 0x61, 0x9d, 0x4e, 0x2b, 0x76, 0xfd, 0x7a, 0xbd, 0x96, 0xe7, 0x23, - 0x2d, 0x50, 0x58, 0xa7, 0xb3, 0xbf, 0x63, 0xc1, 0x43, 0x17, 0x56, 0x56, 0x53, 0x8f, 0xcc, 0x2e, - 0x37, 0x6d, 0xaa, 0xdc, 0xb9, 0x5a, 0x53, 0x52, 0xe5, 0xae, 0xc6, 0x5a, 0x21, 0xb0, 0x1f, 0x96, - 0x10, 0x84, 0x5f, 0xb5, 0xe0, 0xc4, 0x05, 0x2f, 0xc1, 0xa4, 0x1d, 0x66, 0x1d, 0x86, 0x23, 0xd2, - 0x0e, 0x63, 0x2f, 0x09, 0xa3, 0xbd, 0xac, 0xc3, 0x30, 0x56, 0x18, 0xac, 0x51, 0xf1, 0x9a, 0x77, - 0xbd, 0x98, 0xb6, 0xb4, 0x64, 0x9e, 0x30, 0xb1, 0x80, 0x63, 0x45, 0x41, 0x3f, 0xcc, 0xf5, 0x22, - 0xa6, 0x21, 0xec, 0x89, 0xe5, 0xac, 0x3e, 0xac, 0x26, 0x11, 0x38, 0xa5, 0xb1, 0xbf, 0x6a, 0xc1, - 0xa9, 0x0b, 0x7e, 0x27, 0x4e, 0x48, 0xb4, 0x11, 0x1b, 0x8d, 0x7d, 0x16, 0x2a, 0x44, 0x6a, 0xe1, - 0xa2, 0xad, 0x6a, 0xdf, 0x50, 0xea, 0x39, 0xf7, 0x56, 0x56, 0x74, 0x03, 0xf8, 0x76, 0x1e, 0xcd, - 0x27, 0xf1, 0xeb, 0x25, 0x98, 0xbc, 0xb8, 0xbe, 0xde, 0xb8, 0x40, 0x12, 0x21, 0x32, 0xfb, 0x5b, - 0x91, 0xb0, 0x76, 0x10, 0xee, 0xa5, 0xeb, 0x74, 0x12, 0xcf, 0x5f, 0xe0, 0xe1, 0x31, 0x0b, 0xf5, - 0x20, 0xb9, 0x16, 0x35, 0x93, 0xc8, 0x0b, 0x36, 0x73, 0x8f, 0xce, 0x52, 0xb0, 0x97, 0x8b, 0x04, - 0x3b, 0x7a, 0x16, 0x46, 0x58, 0x7c, 0x8e, 0xd4, 0x3a, 0x1e, 0x50, 0xaa, 0x02, 0x83, 0x1e, 0xee, - 0xcf, 0x57, 0xae, 0xe3, 0x3a, 0xff, 0x83, 0x05, 0x29, 0xba, 0x0e, 0xe3, 0x5b, 0x49, 0xd2, 0xbe, - 0x48, 0x1c, 0x97, 0x44, 0x52, 0x3a, 0x9c, 0xc9, 0x93, 0x0e, 0xb4, 0x13, 0x38, 0x59, 0xba, 0xa0, - 0x52, 0x58, 0x8c, 0x75, 0x3e, 0x76, 0x13, 0x20, 0xc5, 0xdd, 0xa5, 0x63, 0x83, 0xfd, 0x03, 0x0b, - 0x46, 0x2f, 0x3a, 0x81, 0xeb, 0x93, 0x08, 0xbd, 0x0c, 0x43, 0xe4, 0x36, 0x69, 0x89, 0x1d, 0x3c, - 0xb7, 0xc1, 0xe9, 0x2e, 0xc7, 0x0d, 0x61, 0xf4, 0x3f, 0x66, 0xa5, 0xd0, 0x45, 0x18, 0xa5, 0xad, - 0xbd, 0xa0, 0xfc, 0xc6, 0x1f, 0x2e, 0xfa, 0x62, 0x35, 0xec, 0x7c, 0x63, 0x14, 0x20, 0x2c, 0x8b, - 0x33, 0x83, 0x4e, 0xab, 0xdd, 0xa4, 0x02, 0x2c, 0xe9, 0x75, 0xdc, 0x5a, 0x5f, 0x69, 0x70, 0x22, - 0xc1, 0x8d, 0x1b, 0x74, 0x24, 0x10, 0xa7, 0x4c, 0xec, 0x75, 0xa8, 0xd0, 0x41, 0x5d, 0xf2, 0x3d, - 0xa7, 0xb7, 0x2d, 0xe9, 0x49, 0xa8, 0x48, 0xbb, 0x4e, 0x2c, 0x5c, 0xcf, 0x19, 0x57, 0x69, 0xf6, - 0x89, 0x71, 0x8a, 0xb7, 0x37, 0xe0, 0x24, 0xbb, 0x28, 0x75, 0x92, 0x2d, 0x63, 0x8d, 0xf5, 0x9f, - 0xcc, 0x4f, 0x09, 0xfd, 0x8a, 0x8f, 0x4c, 0x55, 0xf3, 0x95, 0x9d, 0x90, 0x1c, 0x35, 0x5d, 0xeb, - 0x3f, 0x0f, 0xc1, 0x6c, 0xbd, 0xb9, 0xd2, 0x34, 0x8d, 0x8b, 0x2f, 0xc2, 0x04, 0xd7, 0x04, 0xe8, - 0x84, 0x76, 0x7c, 0x51, 0x9b, 0xba, 0x3c, 0x58, 0xd7, 0x70, 0xd8, 0xa0, 0x44, 0x0f, 0x41, 0xd9, - 0x7b, 0x37, 0xc8, 0xba, 0xc3, 0xd5, 0x5f, 0xbb, 0x8a, 0x29, 0x9c, 0xa2, 0xa9, 0x52, 0xc1, 0x05, - 0xa8, 0x42, 0x2b, 0xc5, 0xe2, 0x15, 0x98, 0xf2, 0xe2, 0x56, 0xec, 0xd5, 0x03, 0x2a, 0x5d, 0xd2, - 0xb8, 0x8b, 0x54, 0xe3, 0xa7, 0x4d, 0x55, 0x58, 0x9c, 0xa1, 0xd6, 0xa4, 0xf9, 0xf0, 0xc0, 0x8a, - 0x49, 0x5f, 0x0f, 0x6c, 0xaa, 0x73, 0xb5, 0xd9, 0xd7, 0xc5, 0xcc, 0x35, 0x47, 0xe8, 0x5c, 0xfc, - 0x83, 0x63, 0x2c, 0x71, 0xe8, 0x02, 0xcc, 0xb6, 0xb6, 0x9c, 0xf6, 0x52, 0x27, 0xd9, 0xaa, 0x79, - 0x71, 0x2b, 0xdc, 0x25, 0xd1, 0x1e, 0xd3, 0x84, 0xc7, 0x52, 0x23, 0x93, 0x42, 0xac, 0x5c, 0x5c, - 0x6a, 0x50, 0x4a, 0xdc, 0x5d, 0xc6, 0x54, 0x41, 0xe0, 0xae, 0xa9, 0x20, 0x4b, 0x30, 0x2d, 0xeb, - 0x6a, 0x92, 0x98, 0x6d, 0x0f, 0xe3, 0xac, 0x75, 0x2a, 0x2c, 0x4a, 0x80, 0x55, 0xdb, 0xb2, 0xf4, - 0xe8, 0x05, 0x98, 0xf4, 0x02, 0x2f, 0xf1, 0x9c, 0x24, 0x8c, 0xd8, 0xe6, 0x3a, 0xc1, 0x37, 0x0c, - 0x2a, 0xe1, 0xeb, 0x3a, 0x02, 0x9b, 0x74, 0xf6, 0x3b, 0x50, 0x51, 0xfe, 0x66, 0xd2, 0x65, 0xd2, - 0x2a, 0x70, 0x99, 0xec, 0xbf, 0x23, 0x48, 0xab, 0x79, 0x39, 0xd7, 0x6a, 0xfe, 0x77, 0x2c, 0x48, - 0xdd, 0x6e, 0xd0, 0x45, 0xa8, 0xb4, 0x43, 0x76, 0x73, 0x16, 0xc9, 0xeb, 0xe8, 0x07, 0x72, 0x85, - 0x07, 0x17, 0x54, 0xbc, 0xff, 0x1a, 0xb2, 0x04, 0x4e, 0x0b, 0xa3, 0x65, 0x18, 0x6d, 0x47, 0xa4, - 0x99, 0xb0, 0xc0, 0x91, 0xbe, 0x7c, 0xf8, 0x1c, 0xe1, 0xf4, 0x58, 0x16, 0xb4, 0x7f, 0xd3, 0x02, - 0xe0, 0x46, 0x69, 0x27, 0xd8, 0x24, 0xc7, 0x70, 0xd0, 0xae, 0xc1, 0x50, 0xdc, 0x26, 0xad, 0x5e, - 0x77, 0x9a, 0x69, 0x7b, 0x9a, 0x6d, 0xd2, 0x4a, 0x3b, 0x9c, 0xfe, 0xc3, 0xac, 0xb4, 0xfd, 0xb3, - 0x00, 0x53, 0x29, 0x19, 0x3d, 0x00, 0xa1, 0xa7, 0x0d, 0xb7, 0xfc, 0xd3, 0x19, 0xb7, 0xfc, 0x0a, - 0xa3, 0xd6, 0x3c, 0xf1, 0xdf, 0x81, 0xf2, 0x8e, 0x73, 0x5b, 0x9c, 0xb2, 0x9e, 0xec, 0xdd, 0x0c, - 0xca, 0x7f, 0xe1, 0x8a, 0x73, 0x9b, 0xeb, 0xb1, 0x4f, 0xca, 0x09, 0x72, 0xc5, 0xb9, 0x7d, 0xc8, - 0x6f, 0x2e, 0x99, 0x90, 0xa2, 0x87, 0xb9, 0x2f, 0xfc, 0x71, 0xfa, 0x9f, 0x4d, 0x3b, 0x5a, 0x09, - 0xab, 0xcb, 0x0b, 0x84, 0x89, 0x76, 0xa0, 0xba, 0xbc, 0x20, 0x5b, 0x97, 0x17, 0x0c, 0x50, 0x97, - 0x17, 0xa0, 0xf7, 0x60, 0x54, 0x5c, 0x89, 0x30, 0x7f, 0xc2, 0xf1, 0xf3, 0x8b, 0x03, 0xd4, 0x27, - 0x6e, 0x54, 0x78, 0x9d, 0x8b, 0x52, 0x4f, 0x17, 0xd0, 0xbe, 0xf5, 0xca, 0x0a, 0xd1, 0xdf, 0xb2, - 0x60, 0x4a, 0xfc, 0xc6, 0xe4, 0xdd, 0x0e, 0x89, 0x13, 0xa1, 0x0f, 0x7c, 0x62, 0xf0, 0x36, 0x88, - 0x82, 0xbc, 0x29, 0x9f, 0x90, 0x62, 0xd6, 0x44, 0xf6, 0x6d, 0x51, 0xa6, 0x15, 0xe8, 0x9f, 0x5a, - 0x70, 0x72, 0xc7, 0xb9, 0xcd, 0x6b, 0xe4, 0x30, 0xec, 0x24, 0x5e, 0x28, 0xfc, 0x23, 0x5f, 0x1e, - 0x6c, 0xf8, 0xbb, 0x8a, 0xf3, 0x46, 0x4a, 0x57, 0xaa, 0x93, 0x79, 0x24, 0x7d, 0x9b, 0x9a, 0xdb, - 0xae, 0xb9, 0x0d, 0x18, 0x93, 0xf3, 0x2d, 0xe7, 0x34, 0x54, 0xd3, 0x95, 0x9d, 0x23, 0xdf, 0x48, - 0x69, 0xa7, 0x27, 0x56, 0x8f, 0x98, 0x6b, 0xf7, 0xb4, 0x9e, 0x77, 0x60, 0x42, 0x9f, 0x63, 0xf7, - 0xb4, 0xae, 0x77, 0xe1, 0x44, 0xce, 0x5c, 0xba, 0xa7, 0x55, 0xde, 0x82, 0xd3, 0x85, 0xf3, 0xe3, - 0x5e, 0x56, 0x6c, 0x7f, 0xdd, 0xd2, 0xe5, 0xe0, 0x31, 0x98, 0xa7, 0x56, 0x4c, 0xf3, 0xd4, 0x99, - 0xde, 0x2b, 0xa7, 0xc0, 0x46, 0xf5, 0x96, 0xde, 0x68, 0x2a, 0xd5, 0xd1, 0xab, 0x30, 0xe2, 0x53, - 0x88, 0xbc, 0x87, 0xb3, 0xfb, 0xaf, 0xc8, 0x54, 0x97, 0x62, 0xf0, 0x18, 0x0b, 0x0e, 0xf6, 0xef, - 0x58, 0x30, 0x74, 0x0c, 0x3d, 0x81, 0xcd, 0x9e, 0x78, 0xba, 0x90, 0xb5, 0xc8, 0x7d, 0xb0, 0x80, - 0x9d, 0x5b, 0xab, 0xb7, 0x13, 0x12, 0xc4, 0x4c, 0x7d, 0xcf, 0xed, 0x98, 0xff, 0x53, 0x82, 0x71, - 0x5a, 0x95, 0x74, 0x1a, 0x79, 0x09, 0x26, 0x7d, 0xe7, 0x26, 0xf1, 0xa5, 0xc9, 0x3c, 0x7b, 0x88, - 0xbd, 0xac, 0x23, 0xb1, 0x49, 0x4b, 0x0b, 0x6f, 0xe8, 0xb7, 0x07, 0x42, 0x7f, 0x51, 0x85, 0x8d, - 0xab, 0x05, 0x6c, 0xd2, 0xd2, 0xf3, 0xd4, 0x2d, 0x27, 0x69, 0x6d, 0x89, 0x03, 0xae, 0x6a, 0xee, - 0xeb, 0x14, 0x88, 0x39, 0x8e, 0x2a, 0x70, 0x72, 0x76, 0xde, 0x20, 0x11, 0x53, 0xe0, 0xb8, 0x7a, - 0xac, 0x14, 0x38, 0x6c, 0xa2, 0x71, 0x96, 0x3e, 0x27, 0x3e, 0x6f, 0x98, 0xb9, 0xc4, 0x0c, 0x10, - 0x9f, 0x87, 0x1a, 0x70, 0xd2, 0x0b, 0x5a, 0x7e, 0xc7, 0x25, 0xd7, 0x03, 0xae, 0xdd, 0xf9, 0xde, - 0x7b, 0xc4, 0x15, 0x0a, 0xb4, 0xf2, 0x5e, 0xaa, 0xe7, 0xd0, 0xe0, 0xdc, 0x92, 0xf6, 0x4f, 0xc3, - 0x89, 0xcb, 0xa1, 0xe3, 0x2e, 0x3b, 0xbe, 0x13, 0xb4, 0x48, 0x54, 0x0f, 0x36, 0xfb, 0x5e, 0xc8, - 0xeb, 0xd7, 0xe7, 0xa5, 0x7e, 0xd7, 0xe7, 0xf6, 0x16, 0x20, 0xbd, 0x02, 0xe1, 0x0a, 0x86, 0x61, - 0xd4, 0xe3, 0x55, 0x89, 0xe9, 0xff, 0x58, 0xbe, 0x76, 0xdd, 0xd5, 0x32, 0xcd, 0xc9, 0x89, 0x03, - 0xb0, 0x64, 0x64, 0xbf, 0x08, 0xb9, 0xf1, 0x19, 0xfd, 0x8f, 0xd2, 0xf6, 0xf3, 0x30, 0xcb, 0x4a, - 0x1e, 0xed, 0x98, 0x67, 0xff, 0x75, 0x0b, 0xa6, 0xaf, 0x66, 0x22, 0x6a, 0x1f, 0x85, 0x91, 0x98, - 0x44, 0x39, 0xb6, 0xd0, 0x26, 0x83, 0x62, 0x81, 0xbd, 0xeb, 0x36, 0x97, 0x1f, 0x5a, 0x50, 0x51, - 0xe1, 0xef, 0xc7, 0xa0, 0xd4, 0xae, 0x18, 0x4a, 0x6d, 0xae, 0x2d, 0x40, 0x35, 0xa7, 0x48, 0xa7, - 0x45, 0x97, 0x54, 0x6c, 0x68, 0x0f, 0x33, 0x40, 0xca, 0x86, 0x47, 0x12, 0x4e, 0x99, 0x01, 0xa4, - 0x32, 0x5a, 0x94, 0xdd, 0x88, 0x2b, 0xda, 0x0f, 0xc9, 0x8d, 0xb8, 0x6a, 0x4f, 0x81, 0xf4, 0x6b, - 0x68, 0x4d, 0x66, 0xbb, 0xc2, 0xa7, 0x99, 0xe7, 0x28, 0x5b, 0x9b, 0x2a, 0x24, 0x7b, 0x5e, 0x78, - 0x82, 0x0a, 0xe8, 0x21, 0x13, 0x64, 0xe2, 0x1f, 0x4f, 0x55, 0x90, 0x16, 0xb1, 0x2f, 0xc2, 0x74, - 0xa6, 0xc3, 0xd0, 0xf3, 0x30, 0xdc, 0xde, 0x72, 0x62, 0x92, 0xf1, 0x04, 0x1a, 0x6e, 0x50, 0xe0, - 0xe1, 0xfe, 0xfc, 0x94, 0x2a, 0xc0, 0x20, 0x98, 0x53, 0xdb, 0xff, 0xc3, 0x82, 0xa1, 0xab, 0xa1, - 0x7b, 0x1c, 0x93, 0xe9, 0x15, 0x63, 0x32, 0x3d, 0x58, 0x94, 0xe8, 0xa5, 0x70, 0x1e, 0xad, 0x65, - 0xe6, 0xd1, 0x99, 0x42, 0x0e, 0xbd, 0xa7, 0xd0, 0x0e, 0x8c, 0xb3, 0xf4, 0x31, 0xc2, 0x2b, 0xe9, - 0x59, 0xe3, 0x7c, 0x35, 0x9f, 0x39, 0x5f, 0x4d, 0x6b, 0xa4, 0xda, 0x29, 0xeb, 0x71, 0x18, 0x15, - 0x9e, 0x31, 0x59, 0x1f, 0x59, 0x41, 0x8b, 0x25, 0xde, 0xfe, 0xe5, 0x32, 0x18, 0xe9, 0x6a, 0xd0, - 0xef, 0x59, 0xb0, 0x10, 0xf1, 0xa8, 0x20, 0xb7, 0xd6, 0x89, 0xbc, 0x60, 0xb3, 0xd9, 0xda, 0x22, - 0x6e, 0xc7, 0xf7, 0x82, 0xcd, 0xfa, 0x66, 0x10, 0x2a, 0xf0, 0xea, 0x6d, 0xd2, 0xea, 0x30, 0x3b, - 0x78, 0x9f, 0xdc, 0x38, 0xea, 0xe6, 0xf9, 0xfc, 0xc1, 0xfe, 0xfc, 0x02, 0x3e, 0x12, 0x6f, 0x7c, - 0xc4, 0xb6, 0xa0, 0xef, 0x58, 0xb0, 0xc8, 0xb3, 0xb8, 0x0c, 0xde, 0xfe, 0x1e, 0xa7, 0xd1, 0x86, - 0x64, 0x95, 0x32, 0x59, 0x27, 0xd1, 0xce, 0xf2, 0x0b, 0xa2, 0x43, 0x17, 0x1b, 0x47, 0xab, 0x0b, - 0x1f, 0xb5, 0x71, 0xf6, 0xbf, 0x2a, 0xc3, 0x24, 0xed, 0xc5, 0x34, 0x12, 0xfe, 0x79, 0x63, 0x4a, - 0x3c, 0x9c, 0x99, 0x12, 0xb3, 0x06, 0xf1, 0xdd, 0x09, 0x82, 0x8f, 0x61, 0xd6, 0x77, 0xe2, 0xe4, - 0x22, 0x71, 0xa2, 0xe4, 0x26, 0x71, 0xd8, 0x55, 0xaf, 0x98, 0xe6, 0x47, 0xb9, 0x3d, 0x56, 0xe6, - 0xaf, 0xcb, 0x59, 0x66, 0xb8, 0x9b, 0x3f, 0xda, 0x05, 0xc4, 0xae, 0x95, 0x23, 0x27, 0x88, 0xf9, - 0xb7, 0x78, 0xc2, 0x46, 0x7e, 0xb4, 0x5a, 0xe7, 0x44, 0xad, 0xe8, 0x72, 0x17, 0x37, 0x9c, 0x53, - 0x83, 0xe6, 0x2e, 0x30, 0x3c, 0xa8, 0xbb, 0xc0, 0x48, 0x1f, 0x47, 0xf4, 0x1d, 0x98, 0x11, 0xa3, - 0xb2, 0xe1, 0x6d, 0x8a, 0x4d, 0xfa, 0x8d, 0x8c, 0x3b, 0x91, 0x35, 0xb8, 0xe3, 0x43, 0x1f, 0x5f, - 0x22, 0xfb, 0x67, 0xe0, 0x04, 0xad, 0xce, 0x74, 0x9b, 0x8e, 0x11, 0x81, 0xe9, 0xed, 0xce, 0x4d, - 0xe2, 0x93, 0x44, 0xc2, 0x44, 0xa5, 0xb9, 0x6a, 0xbf, 0x59, 0x3a, 0xd5, 0x2d, 0x2f, 0x99, 0x2c, - 0x70, 0x96, 0xa7, 0xfd, 0x2b, 0x16, 0x30, 0xc7, 0xc4, 0x63, 0xd8, 0xfe, 0x3e, 0x65, 0x6e, 0x7f, - 0xd5, 0x22, 0x09, 0x54, 0xb0, 0xf3, 0x3d, 0xc7, 0x87, 0xa5, 0x11, 0x85, 0xb7, 0xf7, 0xa4, 0xee, - 0xdf, 0x5f, 0xe3, 0xfa, 0xdf, 0x16, 0x5f, 0x90, 0x2a, 0x48, 0x12, 0x7d, 0x1e, 0xc6, 0x5a, 0x4e, - 0xdb, 0x69, 0xf1, 0x3c, 0x61, 0x85, 0xd6, 0x1f, 0xa3, 0xd0, 0xc2, 0x8a, 0x28, 0xc1, 0xad, 0x19, - 0x1f, 0x97, 0x5f, 0x29, 0xc1, 0x7d, 0x2d, 0x18, 0xaa, 0xca, 0xb9, 0x6d, 0x98, 0x34, 0x98, 0xdd, - 0xd3, 0xa3, 0xef, 0xe7, 0xf9, 0x76, 0xa1, 0x4e, 0x2c, 0x3b, 0x30, 0x1b, 0x68, 0xff, 0xa9, 0x70, - 0x94, 0xea, 0xf4, 0x47, 0xfb, 0x6d, 0x08, 0x4c, 0x92, 0x6a, 0x8e, 0x97, 0x19, 0x36, 0xb8, 0x9b, - 0xb3, 0xfd, 0xf7, 0x2c, 0xb8, 0x5f, 0x27, 0xd4, 0xe2, 0x57, 0xfb, 0xd9, 0x93, 0x6b, 0x30, 0x16, - 0xb6, 0x49, 0xe4, 0xa4, 0x67, 0xb2, 0x73, 0xb2, 0xd3, 0xaf, 0x09, 0xf8, 0xe1, 0xfe, 0xfc, 0x49, - 0x9d, 0xbb, 0x84, 0x63, 0x55, 0x12, 0xd9, 0x30, 0xc2, 0x3a, 0x23, 0x16, 0xb1, 0xc5, 0x2c, 0x97, - 0x16, 0xbb, 0xee, 0x8a, 0xb1, 0xc0, 0xd8, 0x3f, 0x6b, 0xf1, 0x89, 0xa5, 0x37, 0x1d, 0xbd, 0x0b, - 0x33, 0x3b, 0xf4, 0xf8, 0xb6, 0x7a, 0xbb, 0x1d, 0x71, 0x33, 0xba, 0xec, 0xa7, 0x27, 0xfb, 0xf5, - 0x93, 0xf6, 0x91, 0xcb, 0x55, 0xd1, 0xe6, 0x99, 0x2b, 0x19, 0x66, 0xb8, 0x8b, 0xbd, 0xfd, 0xe7, - 0x25, 0xbe, 0x12, 0x99, 0x56, 0xf7, 0x38, 0x8c, 0xb6, 0x43, 0x77, 0xa5, 0x5e, 0xc3, 0xa2, 0x87, - 0x94, 0xb8, 0x6a, 0x70, 0x30, 0x96, 0x78, 0x74, 0x1e, 0x80, 0xdc, 0x4e, 0x48, 0x14, 0x38, 0xbe, - 0xba, 0x8c, 0x57, 0xca, 0xd3, 0xaa, 0xc2, 0x60, 0x8d, 0x8a, 0x96, 0x69, 0x47, 0xe1, 0xae, 0xe7, - 0xb2, 0xe0, 0x8e, 0xb2, 0x59, 0xa6, 0xa1, 0x30, 0x58, 0xa3, 0xa2, 0x47, 0xe5, 0x4e, 0x10, 0xf3, - 0x0d, 0xd0, 0xb9, 0x29, 0xd2, 0xf1, 0x8c, 0xa5, 0x47, 0xe5, 0xeb, 0x3a, 0x12, 0x9b, 0xb4, 0x68, - 0x09, 0x46, 0x12, 0x87, 0x5d, 0x31, 0x0f, 0x17, 0xbb, 0xec, 0xac, 0x53, 0x0a, 0x3d, 0x71, 0x14, - 0x2d, 0x80, 0x45, 0x41, 0xf4, 0xa6, 0x14, 0xc1, 0x5c, 0x24, 0x0b, 0xd7, 0xab, 0xc2, 0x69, 0xab, - 0x8b, 0x6f, 0x5d, 0x06, 0x0b, 0x97, 0x2e, 0x83, 0x97, 0xfd, 0xc5, 0x0a, 0x40, 0xaa, 0xed, 0xa1, - 0xf7, 0xba, 0x44, 0xc4, 0x53, 0xbd, 0xf5, 0xc3, 0xbb, 0x27, 0x1f, 0xd0, 0x97, 0x2c, 0x18, 0x77, - 0x7c, 0x3f, 0x6c, 0x39, 0x09, 0xeb, 0xe5, 0x52, 0x6f, 0x11, 0x25, 0xea, 0x5f, 0x4a, 0x4b, 0xf0, - 0x26, 0x3c, 0x2b, 0x6f, 0x8f, 0x35, 0x4c, 0xdf, 0x56, 0xe8, 0x15, 0xa3, 0x8f, 0xcb, 0x43, 0x00, - 0x9f, 0x1e, 0x73, 0xd9, 0x43, 0x40, 0x85, 0x49, 0x63, 0x4d, 0xff, 0x47, 0xd7, 0x8d, 0xbc, 0x35, - 0x43, 0xc5, 0x21, 0xba, 0x86, 0xd2, 0xd3, 0x2f, 0x65, 0x0d, 0x6a, 0xe8, 0x2e, 0xe8, 0xc3, 0xc5, - 0x71, 0xec, 0x9a, 0x76, 0xdd, 0xc7, 0xfd, 0xfc, 0x1d, 0x98, 0x76, 0xcd, 0xed, 0x56, 0xcc, 0xa6, - 0xc7, 0x8a, 0xf8, 0x66, 0x76, 0xe7, 0x74, 0x83, 0xcd, 0x20, 0x70, 0x96, 0x31, 0x6a, 0xf0, 0x60, - 0x80, 0x7a, 0xb0, 0x11, 0x0a, 0x17, 0x3e, 0xbb, 0x70, 0x2c, 0xf7, 0xe2, 0x84, 0xec, 0x50, 0xca, - 0x74, 0x1f, 0xbd, 0x2a, 0xca, 0x62, 0xc5, 0x05, 0xbd, 0x0a, 0x23, 0x2c, 0x4a, 0x2b, 0xae, 0x8e, - 0x15, 0xdb, 0x01, 0xcd, 0x00, 0xe3, 0x74, 0x51, 0xb1, 0xbf, 0x31, 0x16, 0x1c, 0xd0, 0x45, 0x99, - 0x26, 0x20, 0xae, 0x07, 0xd7, 0x63, 0xc2, 0xd2, 0x04, 0x54, 0x96, 0x3f, 0x9a, 0x66, 0x00, 0xe0, - 0xf0, 0xdc, 0x14, 0x91, 0x46, 0x49, 0xaa, 0xaf, 0x88, 0xff, 0x32, 0xf3, 0x64, 0x15, 0x8a, 0x9b, - 0x67, 0x66, 0xa7, 0x4c, 0xbb, 0xf3, 0x86, 0xc9, 0x02, 0x67, 0x79, 0x1e, 0xeb, 0xf6, 0x39, 0x17, - 0xc0, 0x4c, 0x76, 0x61, 0xdd, 0xd3, 0xed, 0xfa, 0x07, 0x43, 0x30, 0x65, 0x4e, 0x04, 0xb4, 0x08, - 0x15, 0xc1, 0x44, 0xa5, 0x0c, 0x53, 0x73, 0xfb, 0x8a, 0x44, 0xe0, 0x94, 0x86, 0xa5, 0x4c, 0x63, - 0xc5, 0x35, 0xdf, 0xac, 0x34, 0x65, 0x9a, 0xc2, 0x60, 0x8d, 0x8a, 0x2a, 0xd1, 0x37, 0xc3, 0x30, - 0x51, 0x5b, 0x81, 0x9a, 0x2d, 0xcb, 0x0c, 0x8a, 0x05, 0x96, 0x6e, 0x01, 0xdb, 0x24, 0x0a, 0x88, - 0x6f, 0x5a, 0x32, 0xd5, 0x16, 0x70, 0x49, 0x47, 0x62, 0x93, 0x96, 0x6e, 0x69, 0x61, 0xcc, 0xa6, - 0x9f, 0x50, 0xd5, 0x53, 0x5f, 0xb7, 0x26, 0x8f, 0x52, 0x94, 0x78, 0xf4, 0x06, 0xdc, 0xaf, 0x82, - 0x0a, 0x31, 0xb7, 0x0c, 0xcb, 0x1a, 0x47, 0x8c, 0x93, 0xf5, 0xfd, 0x2b, 0xf9, 0x64, 0xb8, 0xa8, - 0x3c, 0x7a, 0x05, 0xa6, 0x84, 0x0a, 0x2c, 0x39, 0x8e, 0x9a, 0xce, 0x0a, 0x97, 0x0c, 0x2c, 0xce, - 0x50, 0xa3, 0x1a, 0xcc, 0x50, 0x08, 0xd3, 0x42, 0x25, 0x07, 0x1e, 0x1c, 0xa9, 0xf6, 0xfa, 0x4b, - 0x19, 0x3c, 0xee, 0x2a, 0x81, 0x96, 0x60, 0x9a, 0xeb, 0x28, 0xf4, 0x4c, 0xc9, 0xc6, 0x41, 0x78, - 0xd6, 0xaa, 0x85, 0x70, 0xcd, 0x44, 0xe3, 0x2c, 0x3d, 0x7a, 0x11, 0x26, 0x9c, 0xa8, 0xb5, 0xe5, - 0x25, 0xa4, 0x95, 0x74, 0x22, 0x9e, 0x84, 0x43, 0xf3, 0xf6, 0x58, 0xd2, 0x70, 0xd8, 0xa0, 0xb4, - 0xdf, 0x83, 0x13, 0x39, 0x4e, 0xf9, 0x74, 0xe2, 0x38, 0x6d, 0x4f, 0x7e, 0x53, 0xc6, 0x6b, 0x6d, - 0xa9, 0x51, 0x97, 0x5f, 0xa3, 0x51, 0xd1, 0xd9, 0xc9, 0x4c, 0xe2, 0x5a, 0x7a, 0x58, 0x35, 0x3b, - 0xd7, 0x24, 0x02, 0xa7, 0x34, 0xf6, 0xb7, 0x01, 0x34, 0x83, 0xce, 0x00, 0x3e, 0x4b, 0x2f, 0xc2, - 0x84, 0xcc, 0x69, 0xac, 0xe5, 0xd2, 0x54, 0x9f, 0x79, 0x41, 0xc3, 0x61, 0x83, 0x92, 0xb6, 0x2d, - 0x50, 0x99, 0x40, 0x33, 0x3e, 0x72, 0x69, 0x1e, 0xd0, 0x94, 0x06, 0x3d, 0x05, 0x63, 0x31, 0xf1, - 0x37, 0x2e, 0x7b, 0xc1, 0xb6, 0x98, 0xd8, 0x4a, 0x0a, 0x37, 0x05, 0x1c, 0x2b, 0x0a, 0xb4, 0x0c, - 0xe5, 0x8e, 0xe7, 0x8a, 0xa9, 0x2c, 0x37, 0xfc, 0xf2, 0xf5, 0x7a, 0xed, 0x70, 0x7f, 0xfe, 0xe1, - 0xa2, 0x54, 0xcd, 0xf4, 0x68, 0x1f, 0x2f, 0xd0, 0xe5, 0x47, 0x0b, 0xe7, 0xdd, 0x0d, 0x8c, 0x1c, - 0xf1, 0x6e, 0xe0, 0x3c, 0x80, 0xf8, 0x6a, 0x39, 0x97, 0xcb, 0xe9, 0xa8, 0x5d, 0x50, 0x18, 0xac, - 0x51, 0xa1, 0x18, 0x66, 0x5b, 0x11, 0x71, 0xe4, 0x19, 0x9a, 0xbb, 0x97, 0x8f, 0xdd, 0xb9, 0x81, - 0x60, 0x25, 0xcb, 0x0c, 0x77, 0xf3, 0x47, 0x21, 0xcc, 0xba, 0x22, 0x86, 0x35, 0xad, 0xb4, 0x72, - 0x74, 0x9f, 0x76, 0xe6, 0x90, 0x93, 0x65, 0x84, 0xbb, 0x79, 0xa3, 0xb7, 0x61, 0x4e, 0x02, 0xbb, - 0xc3, 0x86, 0xd9, 0x72, 0x29, 0x2f, 0x9f, 0x39, 0xd8, 0x9f, 0x9f, 0xab, 0x15, 0x52, 0xe1, 0x1e, - 0x1c, 0x10, 0x86, 0x11, 0x76, 0x97, 0x14, 0x57, 0xc7, 0xd9, 0x3e, 0xf7, 0x44, 0xb1, 0x31, 0x80, - 0xce, 0xf5, 0x05, 0x76, 0x0f, 0x25, 0xdc, 0x7c, 0xd3, 0x6b, 0x39, 0x06, 0xc4, 0x82, 0x13, 0xda, - 0x80, 0x71, 0x27, 0x08, 0xc2, 0xc4, 0xe1, 0x2a, 0xd4, 0x44, 0xb1, 0xee, 0xa7, 0x31, 0x5e, 0x4a, - 0x4b, 0x70, 0xee, 0xca, 0x73, 0x50, 0xc3, 0x60, 0x9d, 0x31, 0xba, 0x05, 0xd3, 0xe1, 0x2d, 0x2a, - 0x1c, 0xa5, 0x95, 0x22, 0xae, 0x4e, 0xb2, 0xba, 0x9e, 0x1b, 0xd0, 0x4e, 0x6b, 0x14, 0xd6, 0xa4, - 0x96, 0xc9, 0x14, 0x67, 0x6b, 0x41, 0x0b, 0x86, 0xb5, 0x7a, 0x2a, 0xf5, 0x67, 0x4f, 0xad, 0xd5, - 0xba, 0x71, 0x9a, 0x85, 0xa1, 0x73, 0xb7, 0x55, 0xb6, 0xfa, 0xa7, 0x33, 0x61, 0xe8, 0x29, 0x0a, - 0xeb, 0x74, 0x68, 0x0b, 0x26, 0xd2, 0x2b, 0xab, 0x28, 0x66, 0x59, 0x6a, 0xc6, 0xcf, 0x9f, 0x1f, - 0xec, 0xe3, 0xea, 0x5a, 0x49, 0x7e, 0x72, 0xd0, 0x21, 0xd8, 0xe0, 0x3c, 0xf7, 0x13, 0x30, 0xae, - 0x0d, 0xec, 0x51, 0xbc, 0xb2, 0xe7, 0x5e, 0x81, 0x99, 0xec, 0xd0, 0x1d, 0xc9, 0xab, 0xfb, 0x7f, - 0x95, 0x60, 0x3a, 0xe7, 0xe6, 0x8a, 0xa5, 0x7b, 0xce, 0x08, 0xd4, 0x34, 0xbb, 0xb3, 0x29, 0x16, - 0x4b, 0x03, 0x88, 0x45, 0x29, 0xa3, 0xcb, 0x85, 0x32, 0x5a, 0x88, 0xc2, 0xa1, 0xf7, 0x23, 0x0a, - 0xcd, 0xdd, 0x67, 0x78, 0xa0, 0xdd, 0xe7, 0x2e, 0x88, 0x4f, 0x63, 0x03, 0x1b, 0x1d, 0x60, 0x03, - 0xfb, 0x85, 0x12, 0xcc, 0x64, 0x73, 0x0a, 0x1f, 0xc3, 0x7d, 0xc7, 0xab, 0xc6, 0x7d, 0x47, 0x7e, - 0xf2, 0xf4, 0x6c, 0xa6, 0xe3, 0xa2, 0xbb, 0x0f, 0x9c, 0xb9, 0xfb, 0x78, 0x62, 0x20, 0x6e, 0xbd, - 0xef, 0x41, 0xfe, 0x7e, 0x09, 0x4e, 0x65, 0x8b, 0xac, 0xf8, 0x8e, 0xb7, 0x73, 0x0c, 0x7d, 0x73, - 0xcd, 0xe8, 0x9b, 0xa7, 0x07, 0xf9, 0x1a, 0xd6, 0xb4, 0xc2, 0x0e, 0x7a, 0x3d, 0xd3, 0x41, 0x8b, - 0x83, 0xb3, 0xec, 0xdd, 0x4b, 0xdf, 0xb6, 0xe0, 0x74, 0x6e, 0xb9, 0x63, 0xb0, 0xbe, 0x5e, 0x35, - 0xad, 0xaf, 0x8f, 0x0f, 0xfc, 0x4d, 0x05, 0xe6, 0xd8, 0xaf, 0x96, 0x0b, 0xbe, 0x85, 0xd9, 0xaf, - 0xae, 0xc1, 0xb8, 0xd3, 0x6a, 0x91, 0x38, 0xbe, 0x12, 0xba, 0x2a, 0xad, 0xd5, 0xd3, 0x6c, 0x4f, - 0x4a, 0xc1, 0x87, 0xfb, 0xf3, 0x73, 0x59, 0x16, 0x29, 0x1a, 0xeb, 0x1c, 0xcc, 0x54, 0x79, 0xa5, - 0xbb, 0x9a, 0x2a, 0xef, 0x3c, 0xc0, 0xae, 0x3a, 0xd5, 0x66, 0x8d, 0x61, 0xda, 0x79, 0x57, 0xa3, - 0x42, 0x3f, 0xc5, 0x74, 0x45, 0xee, 0x32, 0xc2, 0x2f, 0x39, 0x9e, 0x1d, 0x70, 0xac, 0x74, 0xf7, - 0x13, 0x1e, 0x08, 0xab, 0x0c, 0x87, 0x8a, 0x25, 0xfa, 0x0c, 0xcc, 0xc4, 0x3c, 0xd7, 0xc2, 0x8a, - 0xef, 0xc4, 0x2c, 0xfc, 0x42, 0xc8, 0x44, 0x16, 0xdd, 0xda, 0xcc, 0xe0, 0x70, 0x17, 0xb5, 0xfd, - 0x8f, 0xcb, 0xf0, 0x40, 0x8f, 0x29, 0x8a, 0x96, 0xcc, 0x2b, 0xde, 0x27, 0xb3, 0xd6, 0x9d, 0xb9, - 0xdc, 0xc2, 0x86, 0xb9, 0x27, 0x33, 0xc6, 0xa5, 0xf7, 0x3d, 0xc6, 0x5f, 0xb6, 0x34, 0xbb, 0x1b, - 0x77, 0x04, 0xfd, 0xd4, 0x11, 0x97, 0xde, 0x8f, 0xaa, 0xa1, 0xfe, 0x0b, 0x16, 0x3c, 0x9c, 0xfb, - 0x59, 0x86, 0xab, 0xc8, 0x22, 0x54, 0x5a, 0x14, 0xa8, 0x85, 0x48, 0xa5, 0x81, 0x8a, 0x12, 0x81, - 0x53, 0x1a, 0xc3, 0x23, 0xa4, 0xd4, 0xd7, 0x23, 0xe4, 0x5f, 0x5a, 0x70, 0x32, 0xdb, 0x88, 0x63, - 0x90, 0x4c, 0x75, 0x53, 0x32, 0x7d, 0x74, 0x90, 0x21, 0x2f, 0x10, 0x4a, 0x7f, 0x3a, 0x05, 0xf7, - 0x15, 0x64, 0xfc, 0xdf, 0x85, 0xd9, 0xcd, 0x16, 0x31, 0x83, 0xcf, 0xc4, 0xc7, 0xe4, 0xc6, 0xe9, - 0xf5, 0x8c, 0x54, 0xe3, 0xc7, 0x90, 0x2e, 0x12, 0xdc, 0x5d, 0x05, 0xfa, 0x82, 0x05, 0x27, 0x9d, - 0x5b, 0x71, 0xd7, 0x0b, 0x3c, 0x62, 0xce, 0x3c, 0x97, 0x6b, 0x1d, 0xeb, 0xf3, 0x62, 0x0f, 0x0b, - 0x10, 0x39, 0x99, 0x47, 0x85, 0x73, 0xeb, 0x42, 0x58, 0x64, 0xf6, 0xa3, 0x5a, 0x4e, 0x8f, 0xf0, - 0xc8, 0xbc, 0xe0, 0x15, 0x2e, 0xa3, 0x24, 0x06, 0x2b, 0x3e, 0xe8, 0x06, 0x54, 0x36, 0x65, 0x44, - 0x99, 0x90, 0x81, 0xb9, 0x9b, 0x4a, 0x6e, 0xd8, 0x19, 0xf7, 0xd8, 0x57, 0x28, 0x9c, 0xb2, 0x42, - 0xaf, 0x40, 0x39, 0xd8, 0x88, 0x7b, 0x3d, 0x79, 0x90, 0xf1, 0xa0, 0xe2, 0x71, 0xae, 0x57, 0xd7, - 0x9a, 0x98, 0x16, 0xa4, 0xe5, 0xa3, 0x9b, 0xae, 0x30, 0xe8, 0xe6, 0x96, 0xc7, 0xcb, 0xb5, 0xee, - 0xf2, 0x78, 0xb9, 0x86, 0x69, 0x41, 0xb4, 0x06, 0xc3, 0x2c, 0x40, 0x45, 0x58, 0x6b, 0x73, 0xe3, - 0xf4, 0xbb, 0x82, 0x6f, 0x78, 0xe0, 0x2b, 0x03, 0x63, 0x5e, 0x1c, 0xbd, 0x0a, 0x23, 0x2d, 0xf6, - 0x02, 0x80, 0x38, 0x5a, 0xe7, 0xe7, 0x9e, 0xe8, 0x7a, 0x23, 0x80, 0xdf, 0x51, 0x71, 0x38, 0x16, - 0x1c, 0xd0, 0x3a, 0x8c, 0xb4, 0x48, 0x7b, 0x6b, 0x23, 0x16, 0x27, 0xe6, 0x8f, 0xe7, 0xf2, 0xea, - 0xf1, 0xe0, 0x85, 0xe0, 0xca, 0x28, 0xb0, 0xe0, 0x85, 0x3e, 0x09, 0xa5, 0x8d, 0x96, 0x88, 0x55, - 0xc9, 0xb5, 0xd2, 0x9a, 0xc1, 0xc8, 0xcb, 0x23, 0x07, 0xfb, 0xf3, 0xa5, 0xb5, 0x15, 0x5c, 0xda, - 0x68, 0xa1, 0xab, 0x30, 0xba, 0xc1, 0x23, 0x4a, 0x45, 0xa6, 0xd6, 0xc7, 0xf2, 0x83, 0x5d, 0xbb, - 0x82, 0x4e, 0x79, 0x8c, 0x85, 0x40, 0x60, 0xc9, 0x04, 0xad, 0x03, 0x6c, 0xa8, 0xc8, 0x58, 0x91, - 0xaa, 0xf5, 0xa3, 0x83, 0xc4, 0xcf, 0x8a, 0xe3, 0xa3, 0x82, 0x62, 0x8d, 0x0f, 0xfa, 0x1c, 0x54, - 0x1c, 0xf9, 0xa6, 0x0b, 0x4b, 0xd3, 0x6a, 0xee, 0xd3, 0xe9, 0x82, 0xeb, 0xfd, 0xdc, 0x0d, 0x9f, - 0xad, 0x8a, 0x08, 0xa7, 0x4c, 0xd1, 0x36, 0x4c, 0xee, 0xc6, 0xed, 0x2d, 0x22, 0x17, 0x28, 0xcb, - 0xdd, 0x6a, 0x1e, 0x35, 0xd3, 0x44, 0xbb, 0x82, 0xd0, 0x8b, 0x92, 0x8e, 0xe3, 0x77, 0xc9, 0x14, - 0x16, 0x90, 0x73, 0x43, 0x67, 0x86, 0x4d, 0xde, 0xb4, 0xd3, 0xdf, 0xed, 0x84, 0x37, 0xf7, 0x12, - 0x22, 0x32, 0xba, 0xe6, 0x76, 0xfa, 0x6b, 0x9c, 0xa4, 0xbb, 0xd3, 0x05, 0x02, 0x4b, 0x26, 0x74, - 0x09, 0x3b, 0xf2, 0xbd, 0x24, 0x71, 0x46, 0x7e, 0xbc, 0xb0, 0x7b, 0xba, 0xda, 0x9b, 0x76, 0x0a, - 0x93, 0x7d, 0x29, 0x2b, 0x26, 0xf3, 0xda, 0x5b, 0x61, 0x12, 0x06, 0x19, 0x79, 0x3b, 0x5b, 0x2c, - 0xf3, 0x1a, 0x39, 0xf4, 0xdd, 0x32, 0x2f, 0x8f, 0x0a, 0xe7, 0xd6, 0x85, 0x5c, 0x98, 0x6a, 0x87, - 0x51, 0x72, 0x2b, 0x8c, 0xe4, 0xac, 0x42, 0x3d, 0x0e, 0x4f, 0x06, 0xa5, 0xa8, 0x91, 0xf9, 0xd7, - 0x9a, 0x18, 0x9c, 0xe1, 0x49, 0x87, 0x24, 0x6e, 0x39, 0x3e, 0xa9, 0x5f, 0xab, 0x9e, 0x28, 0x1e, - 0x92, 0x26, 0x27, 0xe9, 0x1e, 0x12, 0x81, 0xc0, 0x92, 0x09, 0x95, 0x3e, 0x2c, 0x39, 0x38, 0x4b, - 0x41, 0x5b, 0x20, 0x7d, 0xba, 0x3c, 0x4f, 0xb9, 0xf4, 0x61, 0x60, 0xcc, 0x8b, 0xd3, 0x99, 0x2f, - 0x74, 0xc2, 0x30, 0xae, 0x9e, 0x2a, 0x9e, 0xf9, 0x42, 0x95, 0xbc, 0xd6, 0xec, 0x35, 0xf3, 0x15, - 0x11, 0x4e, 0x99, 0xda, 0xdf, 0x18, 0xe9, 0xd6, 0x16, 0x98, 0xee, 0xff, 0x45, 0xab, 0xeb, 0xfa, - 0xf4, 0x13, 0x83, 0x1e, 0x58, 0xef, 0xe2, 0x45, 0xea, 0x17, 0x2c, 0xb8, 0xaf, 0x9d, 0xfb, 0x51, - 0x62, 0xeb, 0x1d, 0xec, 0xdc, 0xcb, 0xbb, 0x41, 0x25, 0x77, 0xce, 0xc7, 0xe3, 0x82, 0x9a, 0xb2, - 0x3a, 0x72, 0xf9, 0x7d, 0xeb, 0xc8, 0x57, 0x60, 0x8c, 0xa9, 0x77, 0x69, 0x22, 0x99, 0x81, 0x9c, - 0x90, 0xd8, 0x26, 0xbe, 0x22, 0x0a, 0x62, 0xc5, 0x02, 0xfd, 0x9c, 0x05, 0x0f, 0x65, 0x9b, 0x8e, - 0x09, 0x43, 0x8b, 0xc4, 0x84, 0xfc, 0xd8, 0xb1, 0x26, 0xbe, 0xff, 0xa1, 0x46, 0x2f, 0xe2, 0xc3, - 0x7e, 0x04, 0xb8, 0x77, 0x65, 0xa8, 0x96, 0x73, 0xee, 0x19, 0x31, 0x6f, 0x57, 0xfa, 0x9f, 0x7d, - 0xd0, 0x73, 0x30, 0xb1, 0x13, 0x76, 0x02, 0x19, 0x21, 0x20, 0xe2, 0x3f, 0x99, 0x25, 0xef, 0x8a, - 0x06, 0xc7, 0x06, 0xd5, 0xf1, 0xea, 0xfb, 0x5f, 0xb3, 0x72, 0x14, 0x55, 0x7e, 0x32, 0x7b, 0xd9, - 0x3c, 0x99, 0x3d, 0x9a, 0x3d, 0x99, 0x75, 0xd9, 0x59, 0x8c, 0x43, 0xd9, 0xe0, 0x09, 0x57, 0x07, - 0xcd, 0xb4, 0x63, 0xfb, 0x70, 0xb6, 0x9f, 0x70, 0x66, 0x8e, 0x58, 0xae, 0xba, 0xa1, 0x4c, 0x1d, - 0xb1, 0xdc, 0x7a, 0x0d, 0x33, 0xcc, 0xa0, 0x39, 0x1b, 0xec, 0xff, 0x66, 0x41, 0xb9, 0x11, 0xba, - 0xc7, 0x60, 0x37, 0xfa, 0x94, 0x61, 0x37, 0x7a, 0xa0, 0xe0, 0xf5, 0xc5, 0x42, 0x2b, 0xd1, 0x6a, - 0xc6, 0x4a, 0xf4, 0x50, 0x11, 0x83, 0xde, 0x36, 0xa1, 0x7f, 0x50, 0x06, 0xfd, 0xad, 0x48, 0xf4, - 0xaf, 0xef, 0xc4, 0xa3, 0xb7, 0xdc, 0xeb, 0xf9, 0x48, 0xc1, 0x99, 0xf9, 0x6f, 0xc9, 0x60, 0xc1, - 0x1f, 0x31, 0xc7, 0xde, 0xd7, 0x89, 0xb7, 0xb9, 0x95, 0x10, 0x37, 0xfb, 0x39, 0xc7, 0xe7, 0xd8, - 0xfb, 0x5f, 0x2c, 0x98, 0xce, 0xd4, 0x8e, 0xfc, 0xbc, 0xc8, 0xa3, 0x3b, 0xb4, 0x04, 0xcd, 0xf6, - 0x0d, 0x55, 0x5a, 0x00, 0x50, 0x46, 0x79, 0x69, 0x6d, 0x61, 0xba, 0xaf, 0xb2, 0xda, 0xc7, 0x58, - 0xa3, 0x40, 0xcf, 0xc3, 0x78, 0x12, 0xb6, 0x43, 0x3f, 0xdc, 0xdc, 0xbb, 0x44, 0x64, 0x96, 0x10, - 0x75, 0x75, 0xb2, 0x9e, 0xa2, 0xb0, 0x4e, 0x67, 0xff, 0x6a, 0x19, 0xb2, 0xef, 0x8b, 0xfe, 0xff, - 0x39, 0xf9, 0xe1, 0x9c, 0x93, 0xdf, 0xb5, 0x60, 0x86, 0xd6, 0xce, 0x7c, 0x63, 0xa4, 0x4b, 0xac, - 0x7a, 0x99, 0xc1, 0xea, 0xf1, 0x32, 0xc3, 0xa3, 0x54, 0x76, 0xb9, 0x61, 0x27, 0x11, 0x56, 0x21, - 0x4d, 0x38, 0x51, 0x28, 0x16, 0x58, 0x41, 0x47, 0xa2, 0x48, 0xc4, 0x13, 0xe9, 0x74, 0x24, 0x8a, - 0xb0, 0xc0, 0xca, 0x87, 0x1b, 0x86, 0x0a, 0x1e, 0x6e, 0x60, 0x09, 0xb6, 0x84, 0x3f, 0x86, 0x50, - 0x28, 0xb4, 0x04, 0x5b, 0xd2, 0x51, 0x23, 0xa5, 0xb1, 0xbf, 0x5e, 0x86, 0x89, 0x46, 0xe8, 0xa6, - 0x5e, 0xf4, 0xcf, 0x19, 0x5e, 0xf4, 0x67, 0x33, 0x5e, 0xf4, 0x33, 0x3a, 0xed, 0xdd, 0x71, 0xa2, - 0x17, 0xe9, 0xd7, 0xd8, 0x33, 0x22, 0x77, 0xe8, 0x40, 0x6f, 0xa4, 0x5f, 0x53, 0x8c, 0xb0, 0xc9, - 0xf7, 0xc7, 0xc9, 0x71, 0xfe, 0x2f, 0x2c, 0x98, 0x6a, 0x84, 0x2e, 0x9d, 0xa0, 0x3f, 0x4e, 0xb3, - 0x51, 0x4f, 0xdf, 0x36, 0xd2, 0x23, 0x7d, 0xdb, 0x3f, 0xb4, 0x60, 0xb4, 0x11, 0xba, 0xc7, 0x60, - 0x31, 0x7d, 0xd9, 0xb4, 0x98, 0xde, 0x5f, 0x20, 0x65, 0x0b, 0x8c, 0xa4, 0xbf, 0x55, 0x86, 0x49, - 0xda, 0xce, 0x70, 0x53, 0x8e, 0x92, 0xd1, 0x23, 0xd6, 0x00, 0x3d, 0x42, 0x95, 0xb9, 0xd0, 0xf7, - 0xc3, 0x5b, 0xd9, 0x11, 0x5b, 0x63, 0x50, 0x2c, 0xb0, 0xe8, 0x29, 0x18, 0x6b, 0x47, 0x64, 0xd7, - 0x0b, 0x3b, 0x71, 0x36, 0x22, 0xb1, 0x21, 0xe0, 0x58, 0x51, 0x50, 0xbd, 0x3d, 0xf6, 0x82, 0x16, - 0x91, 0x3e, 0x1a, 0x43, 0xcc, 0x47, 0x83, 0x67, 0xc0, 0xd4, 0xe0, 0xd8, 0xa0, 0x42, 0xaf, 0x43, - 0x85, 0xfd, 0x67, 0xeb, 0xe6, 0xe8, 0xef, 0x32, 0xf0, 0x03, 0xae, 0x64, 0x80, 0x53, 0x5e, 0xe8, - 0x3c, 0x40, 0x22, 0xbd, 0x49, 0x62, 0x11, 0x30, 0xab, 0x34, 0x4a, 0xe5, 0x67, 0x12, 0x63, 0x8d, - 0x0a, 0x3d, 0x09, 0x95, 0xc4, 0xf1, 0xfc, 0xcb, 0x5e, 0x40, 0x62, 0xe1, 0x8d, 0x23, 0xb2, 0x4a, - 0x0b, 0x20, 0x4e, 0xf1, 0x74, 0x47, 0x67, 0xe1, 0xd8, 0xfc, 0x55, 0x97, 0x31, 0x46, 0xcd, 0x76, - 0xf4, 0xcb, 0x0a, 0x8a, 0x35, 0x0a, 0xfb, 0x45, 0x38, 0xd5, 0x08, 0xdd, 0x46, 0x18, 0x25, 0x6b, - 0x61, 0x74, 0xcb, 0x89, 0x5c, 0x39, 0x7e, 0xf3, 0x32, 0xc1, 0x31, 0xdd, 0x75, 0x87, 0xb9, 0x35, - 0xc0, 0x48, 0x5d, 0xfc, 0x2c, 0xdb, 0xd3, 0x8f, 0x18, 0x3a, 0xf1, 0xef, 0x4a, 0x80, 0x1a, 0xcc, - 0xdf, 0xc5, 0x78, 0xfa, 0xe7, 0x6d, 0x98, 0x8a, 0xc9, 0x65, 0x2f, 0xe8, 0xdc, 0x96, 0xe7, 0xab, - 0x1e, 0x71, 0x29, 0xcd, 0x55, 0x9d, 0x92, 0x5b, 0x54, 0x4c, 0x18, 0xce, 0x70, 0xa3, 0x5d, 0x18, - 0x75, 0x82, 0xa5, 0xf8, 0x7a, 0x4c, 0x22, 0xf1, 0xd4, 0x0d, 0xeb, 0x42, 0x2c, 0x81, 0x38, 0xc5, - 0xd3, 0x29, 0xc3, 0xfe, 0x5c, 0x0d, 0x03, 0x1c, 0x86, 0x89, 0x9c, 0x64, 0xec, 0xb1, 0x04, 0x0d, - 0x8e, 0x0d, 0x2a, 0xb4, 0x06, 0x28, 0xee, 0xb4, 0xdb, 0x3e, 0xbb, 0x1e, 0x74, 0xfc, 0x0b, 0x51, - 0xd8, 0x69, 0x73, 0x87, 0x65, 0xf1, 0xce, 0x40, 0xb3, 0x0b, 0x8b, 0x73, 0x4a, 0x50, 0xc1, 0xb0, - 0x11, 0xb3, 0xdf, 0x22, 0x22, 0x9b, 0xdb, 0x36, 0x9b, 0x0c, 0x84, 0x25, 0xce, 0xfe, 0x3c, 0xdb, - 0xcc, 0xd8, 0x0b, 0x25, 0x49, 0x27, 0x22, 0x68, 0x07, 0x26, 0xdb, 0x6c, 0xc3, 0x4a, 0xa2, 0xd0, - 0xf7, 0x89, 0xd4, 0x1b, 0xef, 0xcc, 0xf7, 0x86, 0xbf, 0x58, 0xa0, 0xb3, 0xc3, 0x26, 0x77, 0xfb, - 0x8b, 0xd3, 0x4c, 0x2e, 0x35, 0xf9, 0xa1, 0x65, 0x54, 0x78, 0xd4, 0x0a, 0x0d, 0x6d, 0xae, 0xf8, - 0x45, 0xb0, 0x54, 0xd2, 0x0b, 0xaf, 0x5c, 0x2c, 0xcb, 0xa2, 0xd7, 0x98, 0xa7, 0x37, 0x17, 0x06, - 0xfd, 0xde, 0x22, 0xe4, 0x54, 0x86, 0x97, 0xb7, 0x28, 0x88, 0x35, 0x26, 0xe8, 0x32, 0x4c, 0x8a, - 0x07, 0x2d, 0x84, 0xe1, 0xa1, 0x6c, 0x1c, 0x7f, 0x27, 0xb1, 0x8e, 0x3c, 0xcc, 0x02, 0xb0, 0x59, - 0x18, 0x6d, 0xc2, 0x43, 0xda, 0xf3, 0x4b, 0x39, 0xfe, 0x5f, 0x5c, 0xb6, 0x3c, 0x7c, 0xb0, 0x3f, - 0xff, 0xd0, 0x7a, 0x2f, 0x42, 0xdc, 0x9b, 0x0f, 0xba, 0x06, 0xa7, 0x9c, 0x56, 0xe2, 0xed, 0x92, - 0x1a, 0x71, 0x5c, 0xdf, 0x0b, 0x88, 0x19, 0xa2, 0x7f, 0xfa, 0x60, 0x7f, 0xfe, 0xd4, 0x52, 0x1e, - 0x01, 0xce, 0x2f, 0x87, 0x5e, 0x86, 0x8a, 0x1b, 0xc4, 0xa2, 0x0f, 0x46, 0x8c, 0x97, 0xc5, 0x2a, - 0xb5, 0xab, 0x4d, 0xf5, 0xfd, 0xe9, 0x1f, 0x9c, 0x16, 0x40, 0x9b, 0x30, 0xa1, 0x87, 0xe1, 0x88, - 0x57, 0xe9, 0x9e, 0xee, 0x71, 0xb6, 0x35, 0x62, 0x57, 0xb8, 0xd5, 0x4d, 0x79, 0x57, 0x1a, 0x61, - 0x2d, 0x06, 0x63, 0xf4, 0x2a, 0xa0, 0x98, 0x44, 0xbb, 0x5e, 0x8b, 0x2c, 0xb5, 0x58, 0x8a, 0x58, - 0x66, 0xab, 0x19, 0x33, 0x42, 0x05, 0x50, 0xb3, 0x8b, 0x02, 0xe7, 0x94, 0x42, 0x17, 0xa9, 0x44, - 0xd1, 0xa1, 0xc2, 0x19, 0x56, 0xaa, 0x79, 0xd5, 0x1a, 0x69, 0x47, 0xa4, 0xe5, 0x24, 0xc4, 0x35, - 0x39, 0xe2, 0x4c, 0x39, 0xba, 0xdf, 0xa8, 0xcc, 0xfb, 0x60, 0xba, 0x70, 0x76, 0x67, 0xdf, 0xa7, - 0x27, 0xa4, 0xad, 0x30, 0x4e, 0xae, 0x92, 0xe4, 0x56, 0x18, 0x6d, 0x8b, 0xbc, 0x5a, 0x69, 0xda, - 0xbd, 0x14, 0x85, 0x75, 0x3a, 0xaa, 0x11, 0xb1, 0x4b, 0xb0, 0x7a, 0x8d, 0xdd, 0x53, 0x8c, 0xa5, - 0xeb, 0xe4, 0x22, 0x07, 0x63, 0x89, 0x97, 0xa4, 0xf5, 0xc6, 0x0a, 0xbb, 0x7d, 0xc8, 0x90, 0xd6, - 0x1b, 0x2b, 0x58, 0xe2, 0x11, 0xe9, 0x7e, 0xb5, 0x6d, 0xaa, 0xf8, 0xde, 0xa8, 0x5b, 0x2e, 0x0f, - 0xf8, 0x70, 0x5b, 0x00, 0x33, 0xea, 0xbd, 0x38, 0x9e, 0x70, 0x2c, 0xae, 0x4e, 0xb3, 0x49, 0x32, - 0x78, 0xb6, 0x32, 0x65, 0x8b, 0xab, 0x67, 0x38, 0xe1, 0x2e, 0xde, 0x46, 0xea, 0x87, 0x99, 0xbe, - 0x2f, 0x27, 0x2c, 0x42, 0x25, 0xee, 0xdc, 0x74, 0xc3, 0x1d, 0xc7, 0x0b, 0xd8, 0x65, 0x81, 0xfe, - 0x6c, 0xbe, 0x44, 0xe0, 0x94, 0x06, 0xad, 0xc1, 0x98, 0x23, 0x0e, 0x5f, 0xc2, 0xbc, 0x9f, 0x1b, - 0x0b, 0x2e, 0x0f, 0x68, 0xdc, 0x0e, 0x2a, 0xff, 0x61, 0x55, 0x16, 0xbd, 0x04, 0x93, 0x22, 0x5c, - 0x49, 0x78, 0x1a, 0x9e, 0x30, 0x3d, 0xdb, 0x9b, 0x3a, 0x12, 0x9b, 0xb4, 0xe8, 0xa7, 0x60, 0x8a, - 0x72, 0x49, 0x05, 0x5b, 0xf5, 0xe4, 0x20, 0x12, 0x51, 0xcb, 0x88, 0xad, 0x17, 0xc6, 0x19, 0x66, - 0xc8, 0x85, 0x07, 0x9d, 0x4e, 0x12, 0x32, 0x63, 0xa5, 0x39, 0xff, 0xd7, 0xc3, 0x6d, 0x12, 0x30, - 0xeb, 0xfe, 0xd8, 0xf2, 0xd9, 0x83, 0xfd, 0xf9, 0x07, 0x97, 0x7a, 0xd0, 0xe1, 0x9e, 0x5c, 0xd0, - 0x75, 0x18, 0x4f, 0x42, 0x5f, 0xb8, 0x08, 0xc7, 0xd5, 0xfb, 0x8a, 0x53, 0xd7, 0xac, 0x2b, 0x32, - 0xdd, 0x9c, 0xa0, 0x8a, 0x62, 0x9d, 0x0f, 0x5a, 0xe7, 0x6b, 0x8c, 0x25, 0x5a, 0x24, 0x71, 0xf5, - 0xfe, 0xe2, 0x8e, 0x51, 0xf9, 0x18, 0xcd, 0x25, 0x28, 0x4a, 0x62, 0x9d, 0x0d, 0xba, 0x00, 0xb3, - 0xed, 0xc8, 0x0b, 0xd9, 0xc4, 0x56, 0x86, 0xe2, 0xaa, 0x91, 0xd4, 0x6c, 0xb6, 0x91, 0x25, 0xc0, - 0xdd, 0x65, 0xd0, 0x39, 0xaa, 0xa0, 0x72, 0x60, 0xf5, 0x34, 0x7f, 0x51, 0x83, 0x2b, 0xa7, 0x1c, - 0x86, 0x15, 0x76, 0xee, 0xd3, 0x30, 0xdb, 0x25, 0x29, 0x8f, 0xe4, 0xae, 0xf9, 0xeb, 0xc3, 0x50, - 0x51, 0xe6, 0x40, 0xb4, 0x68, 0x5a, 0x79, 0x4f, 0x67, 0xad, 0xbc, 0x63, 0x54, 0x5f, 0xd3, 0x0d, - 0xbb, 0xeb, 0x39, 0x8f, 0x82, 0x9f, 0x2d, 0x10, 0x0d, 0x83, 0xc7, 0x56, 0x1d, 0xe1, 0xc1, 0xf4, - 0xf4, 0xc0, 0x38, 0xd4, 0xf3, 0xc0, 0x38, 0xe0, 0x03, 0x7d, 0xf4, 0x68, 0xd8, 0x0e, 0xdd, 0x7a, - 0x23, 0xfb, 0x62, 0x55, 0x83, 0x02, 0x31, 0xc7, 0x31, 0xe5, 0x9e, 0x6e, 0xeb, 0x4c, 0xb9, 0x1f, - 0xbd, 0x43, 0xe5, 0x5e, 0x32, 0xc0, 0x29, 0x2f, 0xe4, 0xc3, 0x6c, 0xcb, 0x7c, 0x6c, 0x4c, 0xc5, - 0x53, 0x3d, 0xd2, 0xf7, 0xd9, 0xaf, 0x8e, 0xf6, 0x02, 0xc9, 0x4a, 0x96, 0x0b, 0xee, 0x66, 0x8c, - 0x5e, 0x82, 0xb1, 0x77, 0xc3, 0x98, 0x4d, 0x3b, 0xb1, 0xb7, 0xc9, 0x08, 0x96, 0xb1, 0xd7, 0xae, - 0x35, 0x19, 0xfc, 0x70, 0x7f, 0x7e, 0xbc, 0x11, 0xba, 0xf2, 0x2f, 0x56, 0x05, 0xd0, 0x6d, 0x38, - 0x65, 0x48, 0x04, 0xd5, 0x5c, 0x18, 0xbc, 0xb9, 0x0f, 0x89, 0xea, 0x4e, 0xd5, 0xf3, 0x38, 0xe1, - 0xfc, 0x0a, 0xec, 0x6f, 0x70, 0xa3, 0xa7, 0x30, 0x8d, 0x90, 0xb8, 0xe3, 0x1f, 0xc7, 0x33, 0x03, - 0xab, 0x86, 0xd5, 0xe6, 0x8e, 0x0d, 0xeb, 0x7f, 0x60, 0x31, 0xc3, 0xfa, 0x3a, 0xd9, 0x69, 0xfb, - 0x4e, 0x72, 0x1c, 0x4e, 0xba, 0xaf, 0xc1, 0x58, 0x22, 0x6a, 0xeb, 0xf5, 0x32, 0x82, 0xd6, 0x28, - 0x76, 0xb9, 0xa0, 0x36, 0x44, 0x09, 0xc5, 0x8a, 0x8d, 0xfd, 0xcf, 0xf9, 0x08, 0x48, 0xcc, 0x31, - 0xd8, 0x16, 0x6a, 0xa6, 0x6d, 0x61, 0xbe, 0xcf, 0x17, 0x14, 0xd8, 0x18, 0xfe, 0x99, 0xd9, 0x6e, - 0x76, 0xf6, 0xf8, 0xb0, 0xdf, 0xe8, 0xd8, 0xbf, 0x64, 0xc1, 0xc9, 0x3c, 0x47, 0x00, 0xaa, 0xc4, - 0xf0, 0x93, 0x8f, 0xba, 0xe1, 0x52, 0x3d, 0x78, 0x43, 0xc0, 0xb1, 0xa2, 0x18, 0x38, 0x3b, 0xf9, - 0xd1, 0xd2, 0x35, 0x5d, 0x03, 0xf3, 0x5d, 0x3a, 0xf4, 0x0a, 0xf7, 0xba, 0xb7, 0xd4, 0xc3, 0x71, - 0x47, 0xf3, 0xb8, 0xb7, 0x7f, 0xad, 0x04, 0x27, 0xb9, 0x89, 0x7a, 0x69, 0x37, 0xf4, 0xdc, 0x46, - 0xe8, 0x8a, 0x18, 0x84, 0x37, 0x61, 0xa2, 0xad, 0x1d, 0x57, 0x7b, 0x25, 0x8c, 0xd1, 0x8f, 0xb5, - 0xe9, 0xb1, 0x41, 0x87, 0x62, 0x83, 0x17, 0x72, 0x61, 0x82, 0xec, 0x7a, 0x2d, 0x65, 0xe7, 0x2c, - 0x1d, 0x59, 0xa4, 0xab, 0x5a, 0x56, 0x35, 0x3e, 0xd8, 0xe0, 0x7a, 0x0f, 0xde, 0x10, 0xb1, 0xbf, - 0x62, 0xc1, 0xfd, 0x05, 0xe9, 0x65, 0x68, 0x75, 0xb7, 0xd8, 0x65, 0x80, 0x78, 0xe4, 0x50, 0x55, - 0xc7, 0xaf, 0x08, 0xb0, 0xc0, 0xa2, 0x9f, 0x04, 0xe0, 0x26, 0x7e, 0xf6, 0xa4, 0x7c, 0xa9, 0x77, - 0xfc, 0xba, 0x91, 0x76, 0x41, 0x8b, 0xcd, 0x57, 0x8f, 0xc8, 0x6b, 0xbc, 0xec, 0x5f, 0x29, 0xc3, - 0x30, 0x7f, 0xf1, 0x7a, 0x0d, 0x46, 0xb7, 0x78, 0x32, 0xdb, 0x41, 0xf2, 0xe6, 0xa6, 0xc7, 0x11, - 0x0e, 0xc0, 0xb2, 0x30, 0xba, 0x02, 0x27, 0x44, 0x9c, 0x4b, 0x8d, 0xf8, 0xce, 0x9e, 0x3c, 0xd5, - 0xf2, 0x87, 0x25, 0x64, 0xd2, 0xf3, 0x13, 0xf5, 0x6e, 0x12, 0x9c, 0x57, 0x0e, 0xbd, 0xd2, 0x95, - 0xc2, 0x8e, 0xa7, 0x01, 0x56, 0x3a, 0x70, 0x9f, 0x34, 0x76, 0x2f, 0xc1, 0x64, 0xbb, 0xeb, 0xfc, - 0xae, 0x3d, 0x36, 0x6c, 0x9e, 0xd9, 0x4d, 0x5a, 0xe6, 0x55, 0xd0, 0x61, 0x3e, 0x14, 0xeb, 0x5b, - 0x11, 0x89, 0xb7, 0x42, 0xdf, 0x15, 0x2f, 0x6b, 0xa6, 0x5e, 0x05, 0x19, 0x3c, 0xee, 0x2a, 0x41, - 0xb9, 0x6c, 0x38, 0x9e, 0xdf, 0x89, 0x48, 0xca, 0x65, 0xc4, 0xe4, 0xb2, 0x96, 0xc1, 0xe3, 0xae, - 0x12, 0x74, 0x1e, 0x9d, 0x12, 0xcf, 0x32, 0xca, 0xe8, 0x67, 0xe5, 0x2a, 0x32, 0x2a, 0xfd, 0xdb, - 0x7b, 0x64, 0xe4, 0x10, 0x57, 0xfe, 0xea, 0x61, 0x47, 0xed, 0xc1, 0x2f, 0xe1, 0xd9, 0x2e, 0xb9, - 0xdc, 0xc9, 0xe3, 0x80, 0x7f, 0x62, 0xc1, 0x89, 0x1c, 0xf7, 0x31, 0x2e, 0xaa, 0x36, 0xbd, 0x38, - 0x51, 0xef, 0x19, 0x68, 0xa2, 0x8a, 0xc3, 0xb1, 0xa2, 0xa0, 0xeb, 0x81, 0x0b, 0xc3, 0xac, 0x00, - 0x14, 0x2e, 0x1f, 0x02, 0x7b, 0x34, 0x01, 0x88, 0xce, 0xc2, 0x50, 0x27, 0x26, 0x91, 0x7c, 0x51, - 0x4f, 0xca, 0x6f, 0x66, 0x11, 0x64, 0x18, 0xaa, 0x51, 0x6e, 0x2a, 0x63, 0x9c, 0xa6, 0x51, 0x72, - 0x73, 0x1c, 0xc7, 0xd9, 0x5f, 0x2e, 0xc3, 0x74, 0xc6, 0x01, 0x94, 0x36, 0x64, 0x27, 0x0c, 0xbc, - 0x24, 0x54, 0x19, 0xd4, 0x78, 0xc2, 0x08, 0xd2, 0xde, 0xba, 0x22, 0xe0, 0x58, 0x51, 0xa0, 0x47, - 0xe5, 0x53, 0xab, 0xd9, 0x77, 0x1a, 0x96, 0x6b, 0xc6, 0x6b, 0xab, 0x83, 0x3e, 0xb8, 0xf2, 0x08, - 0x0c, 0xb5, 0x43, 0xf5, 0x0e, 0xb6, 0x1a, 0x4f, 0xbc, 0x5c, 0x6b, 0x84, 0xa1, 0x8f, 0x19, 0x12, - 0x7d, 0x4c, 0x7c, 0x7d, 0xe6, 0xbe, 0x02, 0x3b, 0x6e, 0x18, 0x6b, 0x5d, 0xf0, 0x38, 0x8c, 0x6e, - 0x93, 0xbd, 0xc8, 0x0b, 0x36, 0xb3, 0xb7, 0x35, 0x97, 0x38, 0x18, 0x4b, 0xbc, 0x99, 0xb0, 0x7c, - 0xf4, 0x9e, 0xbc, 0x99, 0x32, 0xd6, 0x77, 0x57, 0xfb, 0x2d, 0x0b, 0xa6, 0x59, 0xb6, 0x52, 0x11, - 0x67, 0xef, 0x85, 0xc1, 0x31, 0xe8, 0x09, 0x8f, 0xc0, 0x70, 0x44, 0x2b, 0xcd, 0x3e, 0x84, 0xc0, - 0x5a, 0x82, 0x39, 0x0e, 0x3d, 0x08, 0x43, 0xac, 0x09, 0x74, 0xf0, 0x26, 0x78, 0xbe, 0xf2, 0x9a, - 0x93, 0x38, 0x98, 0x41, 0x59, 0xc0, 0x13, 0x26, 0x6d, 0xdf, 0xe3, 0x8d, 0x4e, 0xcd, 0xad, 0x1f, - 0x8e, 0x80, 0xa7, 0xdc, 0xa6, 0xbd, 0xbf, 0x80, 0xa7, 0x7c, 0x96, 0xbd, 0x75, 0xf0, 0xff, 0x5e, - 0x82, 0x33, 0xb9, 0xe5, 0xd2, 0x9b, 0xdd, 0x35, 0xe3, 0x66, 0xf7, 0x7c, 0xe6, 0x66, 0xd7, 0xee, - 0x5d, 0xfa, 0xee, 0xdc, 0xf5, 0xe6, 0x5f, 0xc1, 0x96, 0x8f, 0xf1, 0x0a, 0x76, 0x68, 0x50, 0x35, - 0x65, 0xb8, 0x8f, 0x9a, 0xf2, 0x6d, 0x0b, 0x4e, 0xe7, 0x76, 0xd9, 0x87, 0x24, 0xc2, 0x2c, 0xb7, - 0x6d, 0x05, 0x67, 0x88, 0x1f, 0x96, 0x0a, 0xbe, 0x85, 0x9d, 0x26, 0xce, 0x51, 0x39, 0xc3, 0x90, - 0xb1, 0x50, 0xbb, 0x26, 0xb8, 0x8c, 0xe1, 0x30, 0xac, 0xb0, 0xc8, 0xd3, 0x62, 0xb5, 0x78, 0xd3, - 0x5e, 0x3a, 0xd2, 0x92, 0x59, 0x30, 0xad, 0xe3, 0x7a, 0x52, 0x80, 0x6c, 0xdc, 0xd6, 0x15, 0xed, - 0x04, 0x58, 0x1e, 0xfc, 0x04, 0x38, 0x91, 0x7f, 0xfa, 0x43, 0x4b, 0x30, 0xbd, 0xe3, 0x05, 0xec, - 0x35, 0x53, 0x53, 0xef, 0x51, 0x01, 0xae, 0x57, 0x4c, 0x34, 0xce, 0xd2, 0xcf, 0xbd, 0x04, 0x93, - 0x77, 0x6e, 0xb2, 0xfa, 0x6e, 0x19, 0x1e, 0xe8, 0xb1, 0xec, 0xb9, 0xac, 0x37, 0xc6, 0x40, 0x93, - 0xf5, 0x5d, 0xe3, 0xd0, 0x80, 0x93, 0x1b, 0x1d, 0xdf, 0xdf, 0x63, 0x5e, 0x4e, 0xc4, 0x95, 0x14, - 0x42, 0x31, 0x51, 0xa9, 0x88, 0xd7, 0x72, 0x68, 0x70, 0x6e, 0x49, 0xf4, 0x2a, 0xa0, 0xf0, 0x26, - 0x4b, 0x8f, 0xeb, 0xa6, 0xa9, 0x0e, 0x58, 0xc7, 0x97, 0xd3, 0xc5, 0x78, 0xad, 0x8b, 0x02, 0xe7, - 0x94, 0xa2, 0x1a, 0x26, 0x7b, 0x83, 0x5d, 0x35, 0x2b, 0xa3, 0x61, 0x62, 0x1d, 0x89, 0x4d, 0x5a, - 0x74, 0x01, 0x66, 0x9d, 0x5d, 0xc7, 0xe3, 0xa9, 0xaf, 0x24, 0x03, 0xae, 0x62, 0x2a, 0x43, 0xd1, - 0x52, 0x96, 0x00, 0x77, 0x97, 0x41, 0x1b, 0x86, 0x95, 0x8f, 0x67, 0xde, 0x3f, 0x3f, 0xf0, 0x6c, - 0x1d, 0xd8, 0xee, 0x67, 0xff, 0x27, 0x8b, 0x6e, 0x5f, 0x39, 0xcf, 0x67, 0xd2, 0x7e, 0x50, 0xf6, - 0x2b, 0x2d, 0xce, 0x4c, 0xf5, 0xc3, 0x8a, 0x8e, 0xc4, 0x26, 0x2d, 0x9f, 0x10, 0x71, 0xea, 0x64, - 0x6d, 0xe8, 0x89, 0x22, 0x30, 0x53, 0x51, 0xa0, 0x37, 0x60, 0xd4, 0xf5, 0x76, 0xbd, 0x38, 0x8c, - 0xc4, 0x62, 0x39, 0xea, 0xb3, 0xd1, 0x4a, 0x0e, 0xd6, 0x38, 0x1b, 0x2c, 0xf9, 0xd9, 0x5f, 0x2e, - 0xc1, 0xa4, 0xac, 0xf1, 0xb5, 0x4e, 0x98, 0x38, 0xc7, 0xb0, 0x2d, 0x5f, 0x30, 0xb6, 0xe5, 0x8f, - 0xf5, 0x8a, 0x4e, 0x65, 0x4d, 0x2a, 0xdc, 0x8e, 0xaf, 0x65, 0xb6, 0xe3, 0xc7, 0xfa, 0xb3, 0xea, - 0xbd, 0x0d, 0xff, 0xae, 0x05, 0xb3, 0x06, 0xfd, 0x31, 0xec, 0x06, 0x6b, 0xe6, 0x6e, 0xf0, 0x70, - 0xdf, 0x6f, 0x28, 0xd8, 0x05, 0xbe, 0x56, 0xca, 0xb4, 0x9d, 0x49, 0xff, 0x77, 0x61, 0x68, 0xcb, - 0x89, 0xdc, 0x5e, 0x09, 0x1c, 0xbb, 0x0a, 0x2d, 0x5c, 0x74, 0x22, 0x97, 0xcb, 0xf0, 0xa7, 0xd4, - 0xcb, 0x5e, 0x4e, 0xe4, 0xf6, 0x8d, 0x29, 0x60, 0x55, 0xa1, 0x17, 0x61, 0x24, 0x6e, 0x85, 0x6d, - 0xe5, 0x7b, 0x79, 0x96, 0xbf, 0xfa, 0x45, 0x21, 0x87, 0xfb, 0xf3, 0xc8, 0xac, 0x8e, 0x82, 0xb1, - 0xa0, 0x9f, 0xdb, 0x84, 0x8a, 0xaa, 0xfa, 0x9e, 0x7a, 0x95, 0xff, 0x51, 0x19, 0x4e, 0xe4, 0xcc, - 0x0b, 0x14, 0x1b, 0xbd, 0xf5, 0xcc, 0x80, 0xd3, 0xe9, 0x7d, 0xf6, 0x57, 0xcc, 0x4e, 0x2c, 0xae, - 0x18, 0xff, 0x81, 0x2b, 0xbd, 0x1e, 0x93, 0x6c, 0xa5, 0x14, 0xd4, 0xbf, 0x52, 0x5a, 0xd9, 0xb1, - 0x75, 0x35, 0xad, 0x48, 0xb5, 0xf4, 0x9e, 0x8e, 0xe9, 0x9f, 0x95, 0xe1, 0x64, 0x5e, 0x50, 0x3b, - 0xfa, 0x99, 0xcc, 0x73, 0x10, 0xcf, 0x0d, 0x1a, 0x0e, 0xcf, 0xdf, 0x88, 0x10, 0xb9, 0x62, 0x16, - 0xcc, 0x07, 0x22, 0xfa, 0x76, 0xb3, 0xa8, 0x93, 0x05, 0xf9, 0x44, 0xfc, 0x19, 0x0f, 0xb9, 0xc4, - 0x3f, 0x31, 0x70, 0x03, 0xc4, 0xfb, 0x1f, 0x71, 0x26, 0xc8, 0x47, 0x82, 0xfb, 0x07, 0xf9, 0xc8, - 0x9a, 0xe7, 0x3c, 0x18, 0xd7, 0xbe, 0xe6, 0x9e, 0x8e, 0xf8, 0x36, 0xdd, 0x51, 0xb4, 0x76, 0xdf, - 0xd3, 0x51, 0xff, 0x8a, 0x05, 0x19, 0x3f, 0x29, 0x65, 0xff, 0xb0, 0x0a, 0xed, 0x1f, 0x67, 0x61, - 0x28, 0x0a, 0x7d, 0x92, 0x7d, 0x21, 0x00, 0x87, 0x3e, 0xc1, 0x0c, 0xa3, 0x9e, 0xf1, 0x2d, 0x17, - 0x3d, 0xe3, 0x4b, 0x8f, 0xc6, 0x3e, 0xd9, 0x25, 0xd2, 0x1a, 0xa1, 0x64, 0xf2, 0x65, 0x0a, 0xc4, - 0x1c, 0x67, 0xff, 0xc6, 0x10, 0x9c, 0xc8, 0x09, 0x69, 0xa3, 0x07, 0x95, 0x4d, 0x27, 0x21, 0xb7, - 0x9c, 0xbd, 0x6c, 0xd6, 0xd2, 0x0b, 0x1c, 0x8c, 0x25, 0x9e, 0xf9, 0x72, 0xf2, 0xc4, 0x67, 0x19, - 0x1b, 0x91, 0xc8, 0x77, 0x26, 0xb0, 0xf7, 0xea, 0x65, 0xd7, 0xf3, 0x00, 0x71, 0xec, 0xaf, 0x06, - 0x54, 0xf9, 0x72, 0x85, 0xa7, 0x68, 0x9a, 0x25, 0xaf, 0x79, 0x59, 0x60, 0xb0, 0x46, 0x85, 0x6a, - 0x30, 0xd3, 0x8e, 0xc2, 0x84, 0xdb, 0xdd, 0x6a, 0xdc, 0x47, 0x61, 0xd8, 0x0c, 0x4e, 0x6a, 0x64, - 0xf0, 0xb8, 0xab, 0x04, 0x7a, 0x1e, 0xc6, 0x45, 0xc0, 0x52, 0x23, 0x0c, 0x7d, 0x61, 0xa5, 0x51, - 0x37, 0xde, 0xcd, 0x14, 0x85, 0x75, 0x3a, 0xad, 0x18, 0x33, 0xe6, 0x8d, 0xe6, 0x16, 0xe3, 0x06, - 0x3d, 0x8d, 0x2e, 0x93, 0xdb, 0x62, 0x6c, 0xa0, 0xdc, 0x16, 0xa9, 0xdd, 0xaa, 0x32, 0xf0, 0xfd, - 0x05, 0xf4, 0xb5, 0xf4, 0x7c, 0xa3, 0x0c, 0x23, 0x7c, 0x28, 0x8e, 0x41, 0x15, 0x5b, 0x13, 0xb6, - 0x9b, 0x1e, 0x19, 0x05, 0x78, 0x5b, 0x16, 0x6a, 0x4e, 0xe2, 0x70, 0x31, 0xa4, 0x56, 0x43, 0x6a, - 0xe5, 0x41, 0x0b, 0xc6, 0x7a, 0x99, 0xcb, 0x18, 0x27, 0x80, 0xf3, 0xd0, 0x56, 0xcf, 0xdb, 0x00, - 0x31, 0x7b, 0x5d, 0x94, 0xf2, 0x10, 0x19, 0x50, 0x9f, 0xe8, 0x51, 0x7b, 0x53, 0x11, 0xf3, 0x36, - 0xa4, 0x53, 0x50, 0x21, 0xb0, 0xc6, 0x71, 0xee, 0x05, 0xa8, 0x28, 0xe2, 0x7e, 0x27, 0xb9, 0x09, - 0x5d, 0x78, 0x7d, 0x0a, 0xa6, 0x33, 0x75, 0x1d, 0xe9, 0x20, 0xf8, 0xdb, 0x16, 0x4c, 0xf3, 0x26, - 0xaf, 0x06, 0xbb, 0x62, 0xb1, 0xbf, 0x07, 0x27, 0xfd, 0x9c, 0x45, 0x27, 0x46, 0x74, 0xf0, 0x45, - 0xaa, 0x0e, 0x7e, 0x79, 0x58, 0x9c, 0x5b, 0x07, 0x3d, 0xfc, 0xf3, 0x77, 0x91, 0x1d, 0x5f, 0x78, - 0x20, 0x4f, 0xf0, 0xcc, 0xd0, 0x1c, 0x86, 0x15, 0xd6, 0xfe, 0x9e, 0x05, 0xb3, 0x5d, 0xaf, 0xea, - 0x7f, 0xa0, 0x6d, 0x17, 0x89, 0xaf, 0x4b, 0x05, 0x89, 0xaf, 0xf5, 0x4f, 0x2b, 0xf7, 0xfc, 0xb4, - 0x5f, 0xb3, 0x40, 0xcc, 0xc0, 0x63, 0x50, 0xe7, 0x3f, 0x6d, 0xaa, 0xf3, 0x73, 0xc5, 0x93, 0xba, - 0x40, 0x8f, 0xff, 0x0b, 0x0b, 0x66, 0x38, 0x41, 0x7a, 0x79, 0xf1, 0x81, 0x8e, 0xc3, 0x20, 0xaf, - 0xb1, 0xa8, 0xe7, 0x2f, 0xf3, 0x3f, 0xca, 0x18, 0xac, 0xa1, 0x9e, 0x83, 0xe5, 0xca, 0x05, 0x74, - 0x84, 0x57, 0x86, 0x8e, 0x9c, 0xab, 0xcd, 0xfe, 0x53, 0x0b, 0x10, 0xaf, 0x26, 0xfb, 0x20, 0x35, - 0xdf, 0xfa, 0xb4, 0x03, 0x7d, 0x2a, 0x6a, 0x14, 0x06, 0x6b, 0x54, 0x77, 0xa5, 0x7b, 0x32, 0x37, - 0x50, 0xe5, 0xfe, 0x37, 0x50, 0x47, 0xe8, 0xd1, 0xbf, 0x31, 0x04, 0x59, 0x77, 0x47, 0x74, 0x03, - 0x26, 0x5a, 0x4e, 0xdb, 0xb9, 0xe9, 0xf9, 0x5e, 0xe2, 0x91, 0xb8, 0xd7, 0xd5, 0xf5, 0x8a, 0x46, - 0x27, 0xae, 0x7b, 0x34, 0x08, 0x36, 0xf8, 0xa0, 0x05, 0x80, 0x76, 0xe4, 0xed, 0x7a, 0x3e, 0xd9, - 0x64, 0x27, 0x1a, 0x16, 0xf3, 0xc0, 0xef, 0x63, 0x25, 0x14, 0x6b, 0x14, 0x39, 0x3e, 0xf2, 0xe5, - 0x7b, 0xe7, 0x23, 0x3f, 0x74, 0x44, 0x1f, 0xf9, 0xe1, 0x81, 0x7c, 0xe4, 0x31, 0xdc, 0x27, 0xf7, - 0x6e, 0xfa, 0x7f, 0xcd, 0xf3, 0x89, 0x50, 0xd8, 0x78, 0x24, 0xc4, 0xdc, 0xc1, 0xfe, 0xfc, 0x7d, - 0x38, 0x97, 0x02, 0x17, 0x94, 0x44, 0x3f, 0x09, 0x55, 0xc7, 0xf7, 0xc3, 0x5b, 0xaa, 0xd7, 0x56, - 0xe3, 0x96, 0xe3, 0xa7, 0xa9, 0x4b, 0xc7, 0x96, 0x1f, 0x3c, 0xd8, 0x9f, 0xaf, 0x2e, 0x15, 0xd0, - 0xe0, 0xc2, 0xd2, 0xf6, 0x36, 0x9c, 0x68, 0x92, 0x48, 0x3e, 0x5c, 0xa6, 0x96, 0xd8, 0x3a, 0x54, - 0xa2, 0x8c, 0x50, 0x19, 0x28, 0x5c, 0x5e, 0x4b, 0x18, 0x26, 0x85, 0x48, 0xca, 0xc8, 0xfe, 0x73, - 0x0b, 0x46, 0x85, 0x0b, 0xe5, 0x31, 0xe8, 0x32, 0x4b, 0x86, 0x59, 0x69, 0x3e, 0x5f, 0xf0, 0xb2, - 0xc6, 0x14, 0x1a, 0x94, 0xea, 0x19, 0x83, 0xd2, 0xc3, 0xbd, 0x98, 0xf4, 0x36, 0x25, 0xfd, 0x62, - 0x19, 0xa6, 0x4c, 0xf7, 0xd1, 0x63, 0xe8, 0x82, 0xab, 0x30, 0x1a, 0x0b, 0x5f, 0xe5, 0x52, 0xb1, - 0xcf, 0x5b, 0x76, 0x10, 0xd3, 0x9b, 0x71, 0xe1, 0x9d, 0x2c, 0x99, 0xe4, 0x3a, 0x41, 0x97, 0xef, - 0xa1, 0x13, 0x74, 0x3f, 0x0f, 0xde, 0xa1, 0xbb, 0xe1, 0xc1, 0x6b, 0x7f, 0x93, 0x09, 0x7f, 0x1d, - 0x7e, 0x0c, 0x7a, 0xc1, 0x05, 0x73, 0x9b, 0xb0, 0x7b, 0xcc, 0x2c, 0xd1, 0xa8, 0x02, 0xfd, 0xe0, - 0x9f, 0x58, 0x30, 0x2e, 0x08, 0x8f, 0xa1, 0xd9, 0x9f, 0x31, 0x9b, 0xfd, 0x40, 0x8f, 0x66, 0x17, - 0xb4, 0xf7, 0xef, 0x96, 0x54, 0x7b, 0x1b, 0x61, 0x94, 0x0c, 0x94, 0xca, 0x7a, 0x8c, 0x9e, 0x06, - 0xc3, 0x56, 0xe8, 0x8b, 0xcd, 0xfc, 0xc1, 0x34, 0x18, 0x8e, 0xc3, 0x0f, 0xb5, 0xdf, 0x58, 0x51, - 0xb3, 0x58, 0xad, 0x30, 0x4a, 0xc4, 0x06, 0x9a, 0xc6, 0x6a, 0x85, 0x51, 0x82, 0x19, 0x06, 0xb9, - 0x00, 0xe9, 0x8b, 0xee, 0x22, 0x7a, 0xb4, 0x78, 0x15, 0x76, 0x12, 0xcf, 0x5f, 0xf0, 0x82, 0x24, - 0x4e, 0xa2, 0x85, 0x7a, 0x90, 0x5c, 0x8b, 0xf8, 0xd9, 0x40, 0x8b, 0x6e, 0x53, 0xbc, 0xb0, 0xc6, - 0x57, 0x86, 0x57, 0xb0, 0x3a, 0x86, 0xcd, 0xfb, 0x9e, 0xab, 0x02, 0x8e, 0x15, 0x85, 0xfd, 0x02, - 0x93, 0xc9, 0xac, 0x83, 0x8e, 0x16, 0x78, 0xf6, 0x9d, 0x31, 0xd5, 0xb5, 0xcc, 0xd8, 0x5b, 0xd3, - 0xc3, 0xdb, 0x7a, 0x8b, 0x40, 0x5a, 0xb1, 0xee, 0x4a, 0x9c, 0xc6, 0xc0, 0xa1, 0xcf, 0x76, 0x5d, - 0x03, 0x3e, 0xdd, 0x47, 0x96, 0x1e, 0xe1, 0xe2, 0x8f, 0x65, 0xe6, 0x63, 0x19, 0xcc, 0xea, 0x8d, - 0x6c, 0xb2, 0xf1, 0x15, 0x89, 0xc0, 0x29, 0x0d, 0x5a, 0x14, 0x27, 0x4b, 0x6e, 0x66, 0x79, 0x20, - 0x73, 0xb2, 0x94, 0x9f, 0xaf, 0x1d, 0x2d, 0x9f, 0x81, 0x71, 0xf5, 0x80, 0x4b, 0x83, 0xbf, 0x83, - 0x51, 0xe1, 0xba, 0xd4, 0x6a, 0x0a, 0xc6, 0x3a, 0x0d, 0x5a, 0x87, 0xe9, 0x98, 0xbf, 0x2e, 0x23, - 0x23, 0x1e, 0x84, 0xdd, 0xe0, 0x89, 0xcc, 0xdb, 0xf1, 0x12, 0x7d, 0xc8, 0x40, 0x7c, 0xb1, 0xca, - 0x18, 0x89, 0x2c, 0x0b, 0xf4, 0x0a, 0x4c, 0xf9, 0xfa, 0x2b, 0x9b, 0x0d, 0x61, 0x56, 0x50, 0xae, - 0x5c, 0xc6, 0x1b, 0x9c, 0x0d, 0x9c, 0xa1, 0xa6, 0x4a, 0x80, 0x0e, 0x11, 0x09, 0x74, 0x9c, 0x60, - 0x93, 0xc4, 0xe2, 0xf9, 0x09, 0xa6, 0x04, 0x5c, 0x2e, 0xa0, 0xc1, 0x85, 0xa5, 0xd1, 0x8b, 0x30, - 0x21, 0x3f, 0x5f, 0x8b, 0x00, 0x4a, 0x1d, 0x06, 0x35, 0x1c, 0x36, 0x28, 0xd1, 0x2d, 0x38, 0x25, - 0xff, 0xaf, 0x47, 0xce, 0xc6, 0x86, 0xd7, 0x12, 0x01, 0x58, 0xe3, 0x8c, 0xc5, 0x92, 0xf4, 0x9e, - 0x5e, 0xcd, 0x23, 0x3a, 0xdc, 0x9f, 0x3f, 0x2b, 0x7a, 0x2d, 0x17, 0xcf, 0x06, 0x31, 0x9f, 0x3f, - 0xba, 0x02, 0x27, 0xb6, 0x88, 0xe3, 0x27, 0x5b, 0x2b, 0x5b, 0xa4, 0xb5, 0x2d, 0x17, 0x11, 0x8b, - 0x2b, 0xd2, 0xdc, 0xec, 0x2e, 0x76, 0x93, 0xe0, 0xbc, 0x72, 0xe8, 0x2d, 0xa8, 0xb6, 0x3b, 0x37, - 0x7d, 0x2f, 0xde, 0xba, 0x1a, 0x26, 0xec, 0xc6, 0x52, 0xbd, 0x7f, 0x22, 0x02, 0x90, 0x54, 0x4c, - 0x55, 0xa3, 0x80, 0x0e, 0x17, 0x72, 0x40, 0xef, 0xc1, 0xa9, 0xcc, 0x64, 0xe0, 0x4f, 0xea, 0x88, - 0x40, 0xa5, 0xc7, 0xf3, 0x97, 0x53, 0x4e, 0x01, 0x1e, 0x16, 0x97, 0x8b, 0xc2, 0xf9, 0x55, 0xbc, - 0xbf, 0x7b, 0xec, 0x77, 0x69, 0x61, 0x4d, 0xbb, 0x41, 0x9f, 0x83, 0x09, 0x7d, 0x16, 0x89, 0x0d, - 0xe6, 0xd1, 0x7e, 0x2f, 0xca, 0x0a, 0xdd, 0x48, 0xcd, 0x28, 0x1d, 0x87, 0x0d, 0x8e, 0x36, 0x81, - 0xfc, 0xef, 0x43, 0x97, 0x61, 0xac, 0xe5, 0x7b, 0x24, 0x48, 0xea, 0x8d, 0x5e, 0x81, 0xb3, 0x2b, - 0x82, 0x46, 0x74, 0x98, 0xc8, 0xdf, 0xc4, 0x61, 0x58, 0x71, 0xb0, 0x7f, 0xbf, 0x04, 0xf3, 0x7d, - 0x52, 0x78, 0x65, 0x6c, 0x80, 0xd6, 0x40, 0x36, 0xc0, 0x25, 0xf9, 0x9a, 0xcb, 0xd5, 0xcc, 0xf9, - 0x33, 0xf3, 0x52, 0x4b, 0x7a, 0x0a, 0xcd, 0xd2, 0x0f, 0xec, 0xfe, 0xa6, 0x9b, 0x11, 0x87, 0xfa, - 0x7a, 0x01, 0x36, 0x74, 0x7b, 0xf0, 0xf0, 0xe0, 0x1a, 0x7d, 0xa1, 0x29, 0xd8, 0xfe, 0x66, 0x09, - 0x4e, 0xa9, 0x2e, 0xfc, 0xf1, 0xed, 0xb8, 0xeb, 0xdd, 0x1d, 0x77, 0x17, 0x0c, 0xe9, 0xf6, 0x35, - 0x18, 0x69, 0xee, 0xc5, 0xad, 0xc4, 0x1f, 0x40, 0x01, 0x7a, 0xc4, 0x58, 0xa0, 0xe9, 0x36, 0xcd, - 0x1e, 0x64, 0x13, 0xeb, 0xd5, 0xfe, 0xab, 0x16, 0x4c, 0xaf, 0xaf, 0x34, 0x9a, 0x61, 0x6b, 0x9b, - 0x24, 0x4b, 0xdc, 0x4c, 0x84, 0x85, 0xfe, 0x63, 0xdd, 0xa1, 0x5e, 0x93, 0xa7, 0x31, 0x9d, 0x85, - 0xa1, 0xad, 0x30, 0x4e, 0xb2, 0x97, 0x25, 0x17, 0xc3, 0x38, 0xc1, 0x0c, 0x63, 0xff, 0xb1, 0x05, - 0xc3, 0xec, 0x0d, 0xb2, 0x7e, 0x6f, 0xd5, 0x0d, 0xf2, 0x5d, 0xe8, 0x79, 0x18, 0x21, 0x1b, 0x1b, - 0xa4, 0x95, 0x88, 0x51, 0x95, 0x11, 0x39, 0x23, 0xab, 0x0c, 0x4a, 0x37, 0x7d, 0x56, 0x19, 0xff, - 0x8b, 0x05, 0x31, 0xfa, 0x2c, 0x54, 0x12, 0x6f, 0x87, 0x2c, 0xb9, 0xae, 0xb8, 0xa7, 0x38, 0x9a, - 0x4b, 0x9a, 0x52, 0x42, 0xd6, 0x25, 0x13, 0x9c, 0xf2, 0xb3, 0x7f, 0xbe, 0x04, 0x90, 0x46, 0xee, - 0xf5, 0xfb, 0xcc, 0xe5, 0xae, 0x27, 0xf9, 0x1e, 0xcd, 0x79, 0x92, 0x0f, 0xa5, 0x0c, 0x73, 0x1e, - 0xe4, 0x53, 0x5d, 0x55, 0x1e, 0xa8, 0xab, 0x86, 0x8e, 0xd2, 0x55, 0x2b, 0x30, 0x9b, 0x46, 0x1e, - 0x9a, 0x61, 0xd8, 0x2c, 0x5d, 0xef, 0x7a, 0x16, 0x89, 0xbb, 0xe9, 0xed, 0x2f, 0x59, 0x20, 0xdc, - 0x94, 0x07, 0x98, 0xd0, 0x6f, 0xca, 0xd7, 0xb3, 0x8c, 0xbc, 0x82, 0x67, 0x8b, 0xfd, 0xb6, 0x45, - 0x36, 0x41, 0xb5, 0x81, 0x18, 0x39, 0x04, 0x0d, 0x5e, 0xf6, 0xef, 0x5a, 0x30, 0xce, 0xd1, 0x2c, - 0x67, 0xdd, 0x00, 0xad, 0x39, 0x52, 0xb2, 0x67, 0xf6, 0xb0, 0x14, 0x65, 0xac, 0x72, 0x02, 0xeb, - 0x0f, 0x4b, 0x49, 0x04, 0x4e, 0x69, 0xd0, 0xe3, 0x30, 0x1a, 0x77, 0x6e, 0x32, 0xf2, 0x8c, 0xa7, - 0x72, 0x93, 0x83, 0xb1, 0xc4, 0xd3, 0x79, 0x35, 0x93, 0x75, 0x54, 0x47, 0x17, 0x61, 0x84, 0x8b, - 0x0d, 0xb1, 0x8c, 0x7b, 0xdc, 0xca, 0x68, 0xee, 0xed, 0xc0, 0x5f, 0x42, 0x67, 0xe2, 0x46, 0x94, - 0x47, 0x6f, 0xc1, 0xb8, 0x1b, 0xde, 0x0a, 0x6e, 0x39, 0x91, 0xbb, 0xd4, 0xa8, 0x8b, 0x5e, 0xcf, - 0xd5, 0x3e, 0x6a, 0x29, 0x99, 0xee, 0x32, 0xcf, 0x2c, 0x90, 0x29, 0x0a, 0xeb, 0xec, 0xd0, 0x3a, - 0x4b, 0x86, 0xc2, 0xdf, 0x67, 0xed, 0xe5, 0x80, 0xa3, 0x9e, 0x74, 0xd5, 0x38, 0x4f, 0x8a, 0x8c, - 0x29, 0xe2, 0x75, 0xd7, 0x94, 0x91, 0xfd, 0x85, 0x13, 0x60, 0x8c, 0xb6, 0x91, 0x92, 0xd9, 0xba, - 0x4b, 0x29, 0x99, 0x31, 0x8c, 0x91, 0x9d, 0x76, 0xb2, 0x57, 0xf3, 0xa2, 0x5e, 0x39, 0xf2, 0x57, - 0x05, 0x4d, 0x37, 0x4f, 0x89, 0xc1, 0x8a, 0x4f, 0x7e, 0xde, 0xec, 0xf2, 0x07, 0x98, 0x37, 0x7b, - 0xe8, 0x18, 0xf3, 0x66, 0x5f, 0x85, 0xd1, 0x4d, 0x2f, 0xc1, 0xa4, 0x1d, 0x8a, 0x2d, 0x33, 0x77, - 0x26, 0x5c, 0xe0, 0x24, 0xdd, 0xd9, 0x5d, 0x05, 0x02, 0x4b, 0x26, 0xe8, 0x55, 0xb5, 0x06, 0x46, - 0x8a, 0x35, 0xce, 0x6e, 0x03, 0x7e, 0xee, 0x2a, 0x10, 0x79, 0xb2, 0x47, 0xef, 0x34, 0x4f, 0xb6, - 0xca, 0x73, 0x3d, 0xf6, 0xfe, 0xf2, 0x5c, 0x1b, 0x79, 0xc0, 0x2b, 0x77, 0x2f, 0x0f, 0xf8, 0x97, - 0x2c, 0x38, 0xd5, 0xce, 0x4b, 0x89, 0x2f, 0x32, 0x56, 0x3f, 0x3f, 0xf0, 0xd3, 0x00, 0x46, 0x85, - 0xec, 0xe8, 0x91, 0x4b, 0x86, 0xf3, 0xab, 0x93, 0x09, 0xc5, 0xc7, 0xef, 0x34, 0xa1, 0xf8, 0xbd, - 0x49, 0x6d, 0x9d, 0xa6, 0x17, 0x9f, 0x7c, 0xdf, 0xe9, 0xc5, 0x5f, 0x55, 0xe9, 0xc5, 0x7b, 0xa4, - 0x9c, 0xe0, 0xc9, 0xc3, 0xfb, 0x26, 0x15, 0xd7, 0x12, 0x83, 0x4f, 0xdf, 0x8d, 0xc4, 0xe0, 0x6f, - 0x9b, 0xc2, 0x9e, 0x67, 0xa9, 0x7e, 0xb2, 0x8f, 0xb0, 0x37, 0xf8, 0xf6, 0x16, 0xf7, 0x3c, 0x09, - 0xfa, 0xec, 0x1d, 0x25, 0x41, 0xbf, 0xa1, 0xa7, 0x17, 0x47, 0x7d, 0xf2, 0x67, 0x53, 0xa2, 0x01, - 0x93, 0x8a, 0xdf, 0xd0, 0xb7, 0xa0, 0x13, 0xc5, 0x7c, 0xd5, 0x4e, 0xd3, 0xcd, 0x37, 0x6f, 0x13, - 0xea, 0x4e, 0x56, 0x7e, 0xf2, 0x78, 0x92, 0x95, 0x9f, 0xba, 0xeb, 0xc9, 0xca, 0xef, 0x3b, 0x86, - 0x64, 0xe5, 0xf7, 0x7f, 0xa0, 0xc9, 0xca, 0xab, 0xf7, 0x36, 0x59, 0xf9, 0xe9, 0xbb, 0x91, 0xac, - 0xfc, 0x06, 0x54, 0xda, 0x32, 0x96, 0xb1, 0x3a, 0x57, 0x3c, 0x24, 0xb9, 0x01, 0x8f, 0x7c, 0x48, - 0x14, 0x0a, 0xa7, 0xac, 0x28, 0xdf, 0x34, 0x79, 0xf9, 0x03, 0x3d, 0x8c, 0x4b, 0x79, 0xc7, 0xf6, - 0x1e, 0x29, 0xcb, 0xff, 0x5a, 0x09, 0xce, 0xf4, 0x9e, 0xd7, 0xe9, 0x99, 0xbf, 0x91, 0xda, 0xa8, - 0x33, 0x67, 0x7e, 0xa6, 0x74, 0x69, 0x54, 0x03, 0x07, 0x7c, 0x5f, 0x80, 0x59, 0xe5, 0xd2, 0xe5, - 0x7b, 0xad, 0x3d, 0xed, 0xbd, 0x21, 0x15, 0x25, 0xd0, 0xcc, 0x12, 0xe0, 0xee, 0x32, 0x68, 0x09, - 0xa6, 0x0d, 0x60, 0xbd, 0x26, 0x54, 0x72, 0x65, 0x64, 0x68, 0x9a, 0x68, 0x9c, 0xa5, 0xb7, 0xbf, - 0x66, 0xc1, 0xfd, 0x05, 0x19, 0x4c, 0x07, 0x8e, 0x67, 0xde, 0x80, 0xe9, 0xb6, 0x59, 0xb4, 0x4f, - 0xda, 0x03, 0x23, 0x4f, 0xaa, 0x6a, 0x6b, 0x06, 0x81, 0xb3, 0x4c, 0x97, 0xcf, 0x7d, 0xeb, 0xfb, - 0x67, 0x3e, 0xf2, 0x87, 0xdf, 0x3f, 0xf3, 0x91, 0xef, 0x7d, 0xff, 0xcc, 0x47, 0xfe, 0xd2, 0xc1, - 0x19, 0xeb, 0x5b, 0x07, 0x67, 0xac, 0x3f, 0x3c, 0x38, 0x63, 0x7d, 0xef, 0xe0, 0x8c, 0xf5, 0x27, - 0x07, 0x67, 0xac, 0x9f, 0xff, 0xc1, 0x99, 0x8f, 0xbc, 0x59, 0xda, 0x7d, 0xe6, 0xff, 0x05, 0x00, - 0x00, 0xff, 0xff, 0xa5, 0x3e, 0x76, 0x4b, 0x79, 0xce, 0x00, 0x00, + 0xda, 0x79, 0x31, 0x5e, 0xf0, 0xc2, 0xc5, 0x9d, 0xce, 0x06, 0x89, 0x02, 0x92, 0x90, 0x78, 0x71, + 0x8f, 0x04, 0x6e, 0x18, 0x2d, 0x0a, 0x84, 0xd3, 0xf6, 0x16, 0x5b, 0x61, 0x44, 0x16, 0xf7, 0x9e, + 0x59, 0xdc, 0x22, 0x01, 0x89, 0x9c, 0x84, 0xb8, 0x0b, 0xed, 0x28, 0x4c, 0x42, 0x84, 0x38, 0xcd, + 0x82, 0xd3, 0xf6, 0x16, 0x28, 0xcd, 0xc2, 0xde, 0x33, 0x73, 0x4f, 0x6f, 0x79, 0xc9, 0x76, 0x67, + 0x63, 0xa1, 0x15, 0xee, 0x2e, 0x6e, 0x85, 0x5b, 0xe1, 0x22, 0x23, 0xdd, 0xe8, 0x6c, 0xb2, 0x7f, + 0xec, 0x0f, 0xfb, 0xc5, 0x59, 0xcc, 0x5d, 0x49, 0xab, 0x21, 0xb7, 0x12, 0x12, 0xc4, 0x5e, 0x18, + 0xc4, 0x4f, 0x3b, 0x6d, 0x2f, 0x26, 0xd1, 0x1e, 0x89, 0x16, 0xdb, 0x3b, 0x5b, 0x14, 0x17, 0x9b, + 0x04, 0x8b, 0x7b, 0xcf, 0x6c, 0x90, 0xc4, 0xe9, 0x6a, 0xd1, 0xdc, 0x73, 0x29, 0xbb, 0x5d, 0xa7, + 0xb5, 0xed, 0x05, 0x24, 0xda, 0x97, 0x3c, 0x16, 0x23, 0x12, 0x87, 0x9d, 0xa8, 0x45, 0x8e, 0x54, + 0x2a, 0x5e, 0xdc, 0x25, 0x89, 0x93, 0xf3, 0xf5, 0x73, 0x8b, 0x45, 0xa5, 0xa2, 0x4e, 0x90, 0x78, + 0xbb, 0xdd, 0xd5, 0x7c, 0xa2, 0x5f, 0x81, 0xb8, 0xb5, 0x4d, 0x76, 0x9d, 0xae, 0x72, 0xcf, 0x16, + 0x95, 0xeb, 0x24, 0x9e, 0xbf, 0xe8, 0x05, 0x49, 0x9c, 0x44, 0xd9, 0x42, 0xf6, 0x77, 0x2d, 0x38, + 0xbb, 0xf4, 0x7a, 0x73, 0xd5, 0x77, 0xe2, 0xc4, 0x6b, 0x2d, 0xfb, 0x61, 0x6b, 0xa7, 0x99, 0x84, + 0x11, 0xb9, 0x11, 0xfa, 0x9d, 0x5d, 0xd2, 0x64, 0x1d, 0x81, 0x9e, 0x82, 0xb1, 0x3d, 0xf6, 0xbf, + 0x5e, 0xab, 0x5a, 0x67, 0xad, 0x73, 0x95, 0xe5, 0x99, 0x6f, 0x1d, 0xcc, 0x7f, 0xe4, 0xf6, 0xc1, + 0xfc, 0xd8, 0x0d, 0x01, 0xc7, 0x8a, 0x02, 0x3d, 0x0a, 0x23, 0x9b, 0xf1, 0xfa, 0x7e, 0x9b, 0x54, + 0x4b, 0x8c, 0x76, 0x4a, 0xd0, 0x8e, 0xac, 0x35, 0x29, 0x14, 0x0b, 0x2c, 0x5a, 0x84, 0x4a, 0xdb, + 0x89, 0x12, 0x2f, 0xf1, 0xc2, 0xa0, 0x5a, 0x3e, 0x6b, 0x9d, 0x1b, 0x5e, 0x9e, 0x15, 0xa4, 0x95, + 0x86, 0x44, 0xe0, 0x94, 0x86, 0x36, 0x23, 0x22, 0x8e, 0x7b, 0x2d, 0xf0, 0xf7, 0xab, 0x43, 0x67, + 0xad, 0x73, 0x63, 0x69, 0x33, 0xb0, 0x80, 0x63, 0x45, 0x61, 0xff, 0x52, 0x09, 0xc6, 0x96, 0x36, + 0x37, 0xbd, 0xc0, 0x4b, 0xf6, 0xd1, 0x0d, 0x98, 0x08, 0x42, 0x97, 0xc8, 0xff, 0xec, 0x2b, 0xc6, + 0xcf, 0x9f, 0x5d, 0xe8, 0x9e, 0x99, 0x0b, 0x57, 0x35, 0xba, 0xe5, 0x99, 0xdb, 0x07, 0xf3, 0x13, + 0x3a, 0x04, 0x1b, 0x7c, 0x10, 0x86, 0xf1, 0x76, 0xe8, 0x2a, 0xb6, 0x25, 0xc6, 0x76, 0x3e, 0x8f, + 0x6d, 0x23, 0x25, 0x5b, 0x9e, 0xbe, 0x7d, 0x30, 0x3f, 0xae, 0x01, 0xb0, 0xce, 0x04, 0x6d, 0xc0, + 0x34, 0xfd, 0x1b, 0x24, 0x9e, 0xe2, 0x5b, 0x66, 0x7c, 0x1f, 0x29, 0xe2, 0xab, 0x91, 0x2e, 0x9f, + 0xb8, 0x7d, 0x30, 0x3f, 0x9d, 0x01, 0xe2, 0x2c, 0x43, 0xfb, 0x3d, 0x98, 0x5a, 0x4a, 0x12, 0xa7, + 0xb5, 0x4d, 0x5c, 0x3e, 0x82, 0xe8, 0x39, 0x18, 0x0a, 0x9c, 0x5d, 0x22, 0xc6, 0xf7, 0xac, 0xe8, + 0xd8, 0xa1, 0xab, 0xce, 0x2e, 0x39, 0x3c, 0x98, 0x9f, 0xb9, 0x1e, 0x78, 0xef, 0x76, 0xc4, 0xac, + 0xa0, 0x30, 0xcc, 0xa8, 0xd1, 0x79, 0x00, 0x97, 0xec, 0x79, 0x2d, 0xd2, 0x70, 0x92, 0x6d, 0x31, + 0xde, 0x48, 0x94, 0x85, 0x9a, 0xc2, 0x60, 0x8d, 0xca, 0xbe, 0x05, 0x95, 0xa5, 0xbd, 0xd0, 0x73, + 0x1b, 0xa1, 0x1b, 0xa3, 0x1d, 0x98, 0x6e, 0x47, 0x64, 0x93, 0x44, 0x0a, 0x54, 0xb5, 0xce, 0x96, + 0xcf, 0x8d, 0x9f, 0x3f, 0x97, 0xfb, 0xb1, 0x26, 0xe9, 0x6a, 0x90, 0x44, 0xfb, 0xcb, 0xf7, 0x8b, + 0xfa, 0xa6, 0x33, 0x58, 0x9c, 0xe5, 0x6c, 0xff, 0x9b, 0x12, 0x9c, 0x5a, 0x7a, 0xaf, 0x13, 0x91, + 0x9a, 0x17, 0xef, 0x64, 0x67, 0xb8, 0xeb, 0xc5, 0x3b, 0x57, 0xd3, 0x1e, 0x50, 0x53, 0xab, 0x26, + 0xe0, 0x58, 0x51, 0xa0, 0xa7, 0x61, 0x94, 0xfe, 0xbe, 0x8e, 0xeb, 0xe2, 0x93, 0x4f, 0x08, 0xe2, + 0xf1, 0x9a, 0x93, 0x38, 0x35, 0x8e, 0xc2, 0x92, 0x06, 0x5d, 0x81, 0xf1, 0x16, 0x5b, 0x90, 0x5b, + 0x57, 0x42, 0x97, 0xb0, 0xc1, 0xac, 0x2c, 0x3f, 0x49, 0xc9, 0x57, 0x52, 0xf0, 0xe1, 0xc1, 0x7c, + 0x95, 0xb7, 0x4d, 0xb0, 0xd0, 0x70, 0x58, 0x2f, 0x8f, 0x6c, 0xb5, 0xbe, 0x86, 0x18, 0x27, 0xc8, + 0x59, 0x5b, 0xe7, 0xb4, 0xa5, 0x32, 0xcc, 0x96, 0xca, 0x44, 0xfe, 0x32, 0x41, 0xcf, 0xc0, 0xd0, + 0x8e, 0x17, 0xb8, 0xd5, 0x11, 0xc6, 0xeb, 0x21, 0x3a, 0xe6, 0x97, 0xbc, 0xc0, 0x3d, 0x3c, 0x98, + 0x9f, 0x35, 0x9a, 0x43, 0x81, 0x98, 0x91, 0xda, 0x7f, 0x66, 0xc1, 0x3c, 0xc3, 0xad, 0x79, 0x3e, + 0x69, 0x90, 0x28, 0xf6, 0xe2, 0x84, 0x04, 0x89, 0xd1, 0xa1, 0xe7, 0x01, 0x62, 0xd2, 0x8a, 0x48, + 0xa2, 0x75, 0xa9, 0x9a, 0x18, 0x4d, 0x85, 0xc1, 0x1a, 0x15, 0x15, 0x08, 0xf1, 0xb6, 0x13, 0xb1, + 0xf9, 0x25, 0x3a, 0x56, 0x09, 0x84, 0xa6, 0x44, 0xe0, 0x94, 0xc6, 0x10, 0x08, 0xe5, 0x7e, 0x02, + 0x01, 0x7d, 0x0a, 0xa6, 0xd3, 0xca, 0xe2, 0xb6, 0xd3, 0x92, 0x1d, 0xc8, 0x96, 0x4c, 0xd3, 0x44, + 0xe1, 0x2c, 0xad, 0xfd, 0x8f, 0x2c, 0x31, 0x79, 0xe8, 0x57, 0x7f, 0xc8, 0xbf, 0xd5, 0xfe, 0x1d, + 0x0b, 0x46, 0x97, 0xbd, 0xc0, 0xf5, 0x82, 0x2d, 0xf4, 0x39, 0x18, 0xa3, 0x7b, 0x93, 0xeb, 0x24, + 0x8e, 0x90, 0x7b, 0x1f, 0xd7, 0xd6, 0x96, 0xda, 0x2a, 0x16, 0xda, 0x3b, 0x5b, 0x14, 0x10, 0x2f, + 0x50, 0x6a, 0xba, 0xda, 0xae, 0x6d, 0xbc, 0x43, 0x5a, 0xc9, 0x15, 0x92, 0x38, 0xe9, 0xe7, 0xa4, + 0x30, 0xac, 0xb8, 0xa2, 0x4b, 0x30, 0x92, 0x38, 0xd1, 0x16, 0x49, 0x84, 0x00, 0xcc, 0x15, 0x54, + 0xbc, 0x24, 0xa6, 0x2b, 0x92, 0x04, 0x2d, 0x92, 0x6e, 0x0b, 0xeb, 0xac, 0x28, 0x16, 0x2c, 0xec, + 0x16, 0x4c, 0xac, 0x38, 0x6d, 0x67, 0xc3, 0xf3, 0xbd, 0xc4, 0x23, 0x31, 0x7a, 0x0c, 0xca, 0x8e, + 0xeb, 0x32, 0xa9, 0x50, 0x59, 0x3e, 0x75, 0xfb, 0x60, 0xbe, 0xbc, 0xe4, 0xd2, 0xe9, 0x09, 0x8a, + 0x6a, 0x1f, 0x53, 0x0a, 0xf4, 0x04, 0x0c, 0xb9, 0x51, 0xd8, 0xae, 0x96, 0x18, 0xe5, 0x7d, 0x74, + 0x26, 0xd7, 0xa2, 0xb0, 0x9d, 0x21, 0x65, 0x34, 0xf6, 0xef, 0x97, 0xe0, 0xc1, 0x15, 0xd2, 0xde, + 0x5e, 0x6b, 0x16, 0xcc, 0xdf, 0x73, 0x30, 0xb6, 0x1b, 0x06, 0x5e, 0x12, 0x46, 0xb1, 0xa8, 0x9a, + 0x2d, 0xa0, 0x2b, 0x02, 0x86, 0x15, 0x16, 0x9d, 0x85, 0xa1, 0x76, 0x2a, 0xfc, 0x26, 0xa4, 0xe0, + 0x64, 0x62, 0x8f, 0x61, 0x28, 0x45, 0x27, 0x26, 0x91, 0x58, 0xf8, 0x8a, 0xe2, 0x7a, 0x4c, 0x22, + 0xcc, 0x30, 0xe9, 0x0c, 0xa2, 0x73, 0x4b, 0xcc, 0xca, 0xcc, 0x0c, 0xa2, 0x18, 0xac, 0x51, 0xa1, + 0x06, 0x54, 0xf8, 0x3f, 0x4c, 0x36, 0xd9, 0x1a, 0x2f, 0xe8, 0xf7, 0xa6, 0x24, 0x12, 0xfd, 0x3e, + 0xc9, 0xa6, 0x98, 0x04, 0xe2, 0x94, 0x89, 0x31, 0xc5, 0x46, 0xfa, 0x4e, 0xb1, 0x6f, 0x96, 0x00, + 0xf1, 0x2e, 0xfc, 0x11, 0xeb, 0xb8, 0xeb, 0xdd, 0x1d, 0x97, 0xbb, 0xd9, 0x5c, 0x0e, 0x5b, 0x8e, + 0x9f, 0x9d, 0xb5, 0x77, 0xab, 0xf7, 0x7e, 0xd1, 0x02, 0xb4, 0xe2, 0x05, 0x2e, 0x89, 0x8e, 0x41, + 0xd3, 0x3a, 0x9a, 0xec, 0xb8, 0x0c, 0x53, 0x2b, 0xbe, 0x47, 0x82, 0xa4, 0xde, 0x58, 0x09, 0x83, + 0x4d, 0x6f, 0x0b, 0x7d, 0x12, 0xa6, 0xa8, 0xe2, 0x19, 0x76, 0x92, 0x26, 0x69, 0x85, 0x01, 0xdb, + 0xa3, 0xa9, 0xba, 0x86, 0x6e, 0x1f, 0xcc, 0x4f, 0xad, 0x1b, 0x18, 0x9c, 0xa1, 0xb4, 0xff, 0x23, + 0xfd, 0xd0, 0x70, 0xb7, 0x1d, 0x06, 0x24, 0x48, 0x56, 0xc2, 0xc0, 0xe5, 0xba, 0xdc, 0x27, 0x61, + 0x28, 0xa1, 0x0d, 0xe7, 0x1f, 0xf9, 0xa8, 0x1c, 0x5a, 0xda, 0xdc, 0xc3, 0x83, 0xf9, 0xfb, 0xba, + 0x4b, 0xb0, 0x0f, 0x62, 0x65, 0xd0, 0x4f, 0xc0, 0x48, 0x9c, 0x38, 0x49, 0x27, 0x16, 0x9f, 0xfd, + 0xb0, 0xfc, 0xec, 0x26, 0x83, 0x1e, 0x1e, 0xcc, 0x4f, 0xab, 0x62, 0x1c, 0x84, 0x45, 0x01, 0xf4, + 0x38, 0x8c, 0xee, 0x92, 0x38, 0x76, 0xb6, 0xe4, 0x36, 0x3c, 0x2d, 0xca, 0x8e, 0x5e, 0xe1, 0x60, + 0x2c, 0xf1, 0xe8, 0x11, 0x18, 0x26, 0x51, 0x14, 0x46, 0x62, 0x56, 0x4d, 0x0a, 0xc2, 0xe1, 0x55, + 0x0a, 0xc4, 0x1c, 0x67, 0xff, 0x7b, 0x0b, 0xa6, 0x55, 0x5b, 0x79, 0x5d, 0xc7, 0x20, 0x6f, 0xdf, + 0x04, 0x68, 0xc9, 0x0f, 0x8c, 0x99, 0xbc, 0x1b, 0x3f, 0xff, 0x68, 0xde, 0x14, 0xee, 0xee, 0xc6, + 0x94, 0xb3, 0x02, 0xc5, 0x58, 0xe3, 0x66, 0xff, 0x0b, 0x0b, 0x4e, 0x64, 0xbe, 0xe8, 0xb2, 0x17, + 0x27, 0xe8, 0xad, 0xae, 0xaf, 0x5a, 0x18, 0xec, 0xab, 0x68, 0x69, 0xf6, 0x4d, 0x6a, 0xce, 0x49, + 0x88, 0xf6, 0x45, 0x17, 0x61, 0xd8, 0x4b, 0xc8, 0xae, 0xfc, 0x98, 0x47, 0x7a, 0x7e, 0x0c, 0x6f, + 0x55, 0x3a, 0x22, 0x75, 0x5a, 0x12, 0x73, 0x06, 0xf6, 0xff, 0xb4, 0xa0, 0xc2, 0xa7, 0xed, 0x15, + 0xa7, 0x7d, 0x0c, 0x63, 0x51, 0x87, 0x21, 0xc6, 0x9d, 0x37, 0xfc, 0xb1, 0xfc, 0x86, 0x8b, 0xe6, + 0x2c, 0x50, 0x65, 0x8a, 0x2b, 0xad, 0x4a, 0x98, 0x51, 0x10, 0x66, 0x2c, 0xe6, 0x5e, 0x80, 0x8a, + 0x22, 0x40, 0x33, 0x50, 0xde, 0x21, 0xfc, 0xa0, 0x52, 0xc1, 0xf4, 0x27, 0x3a, 0x09, 0xc3, 0x7b, + 0x8e, 0xdf, 0x11, 0x8b, 0x1d, 0xf3, 0x3f, 0x9f, 0x2c, 0xbd, 0x68, 0xd9, 0xdf, 0x60, 0x6b, 0x4c, + 0x54, 0xb2, 0x1a, 0xec, 0x09, 0x61, 0xf2, 0x1e, 0x9c, 0xf4, 0x73, 0x64, 0x98, 0xe8, 0x88, 0xc1, + 0x65, 0xde, 0x83, 0xa2, 0xad, 0x27, 0xf3, 0xb0, 0x38, 0xb7, 0x0e, 0xba, 0x0d, 0x84, 0x6d, 0x3a, + 0xa3, 0x1c, 0x9f, 0xb5, 0x57, 0x28, 0xa0, 0xd7, 0x04, 0x0c, 0x2b, 0x2c, 0x15, 0x10, 0x27, 0x55, + 0xe3, 0x2f, 0x91, 0xfd, 0x26, 0xf1, 0x49, 0x2b, 0x09, 0xa3, 0x0f, 0xb4, 0xf9, 0x0f, 0xf1, 0xde, + 0xe7, 0xf2, 0x65, 0x5c, 0x30, 0x28, 0x5f, 0x22, 0xfb, 0x7c, 0x28, 0xf4, 0xaf, 0x2b, 0xf7, 0xfc, + 0xba, 0xdf, 0xb0, 0x60, 0x52, 0x7d, 0xdd, 0x31, 0x2c, 0xa4, 0x65, 0x73, 0x21, 0x3d, 0xd4, 0x73, + 0x3e, 0x16, 0x2c, 0xa1, 0x1f, 0x32, 0x11, 0x20, 0x68, 0x1a, 0x51, 0x48, 0xbb, 0x86, 0xca, 0xec, + 0x0f, 0x72, 0x40, 0x06, 0xf9, 0xae, 0x4b, 0x64, 0x7f, 0x3d, 0xa4, 0xea, 0x43, 0xfe, 0x77, 0x19, + 0xa3, 0x36, 0xd4, 0x73, 0xd4, 0x7e, 0xb3, 0x04, 0xa7, 0x54, 0x0f, 0x18, 0x1b, 0xf4, 0x8f, 0x7a, + 0x1f, 0x3c, 0x03, 0xe3, 0x2e, 0xd9, 0x74, 0x3a, 0x7e, 0xa2, 0xce, 0xa2, 0xc3, 0xdc, 0x1e, 0x51, + 0x4b, 0xc1, 0x58, 0xa7, 0x39, 0x42, 0xb7, 0xfd, 0x5b, 0x60, 0xb2, 0x37, 0x71, 0xe8, 0x0c, 0xa6, + 0xda, 0x9b, 0x66, 0x51, 0x98, 0xd0, 0x2d, 0x0a, 0xc2, 0x7a, 0xf0, 0x08, 0x0c, 0x7b, 0xbb, 0x74, + 0x2f, 0x2e, 0x99, 0x5b, 0x6c, 0x9d, 0x02, 0x31, 0xc7, 0xa1, 0x8f, 0xc1, 0x68, 0x2b, 0xdc, 0xdd, + 0x75, 0x02, 0xb7, 0x5a, 0x66, 0xfa, 0xe4, 0x38, 0xdd, 0xae, 0x57, 0x38, 0x08, 0x4b, 0x1c, 0x7a, + 0x10, 0x86, 0x9c, 0x68, 0x2b, 0xae, 0x0e, 0x31, 0x9a, 0x31, 0x5a, 0xd3, 0x52, 0xb4, 0x15, 0x63, + 0x06, 0xa5, 0x7a, 0xe2, 0xcd, 0x30, 0xda, 0xf1, 0x82, 0xad, 0x9a, 0x17, 0x31, 0xa5, 0x4f, 0xd3, + 0x13, 0x5f, 0x57, 0x18, 0xac, 0x51, 0xa1, 0x35, 0x18, 0x6e, 0x87, 0x51, 0x12, 0x57, 0x47, 0x58, + 0x77, 0x3f, 0x5c, 0xb0, 0x94, 0xf8, 0xd7, 0x36, 0xc2, 0x28, 0x49, 0x3f, 0x80, 0xfe, 0x8b, 0x31, + 0x2f, 0x8e, 0x7e, 0x02, 0xca, 0x24, 0xd8, 0xab, 0x8e, 0x32, 0x2e, 0x73, 0x79, 0x5c, 0x56, 0x83, + 0xbd, 0x1b, 0x4e, 0x94, 0xca, 0x99, 0xd5, 0x60, 0x0f, 0xd3, 0x32, 0xe8, 0x0d, 0xa8, 0x48, 0x6b, + 0x64, 0x5c, 0x1d, 0x2b, 0x9e, 0x62, 0x58, 0x10, 0x61, 0xf2, 0x6e, 0xc7, 0x8b, 0xc8, 0x2e, 0x09, + 0x92, 0x38, 0x3d, 0x4f, 0x4a, 0x6c, 0x8c, 0x53, 0x6e, 0xe8, 0x0d, 0x98, 0xe0, 0x7a, 0xe4, 0x95, + 0xb0, 0x13, 0x24, 0x71, 0xb5, 0xc2, 0x9a, 0x97, 0x6b, 0xba, 0xba, 0x91, 0xd2, 0x2d, 0x9f, 0x14, + 0x4c, 0x27, 0x34, 0x60, 0x8c, 0x0d, 0x56, 0x08, 0xc3, 0xa4, 0xef, 0xed, 0x91, 0x80, 0xc4, 0x71, + 0x23, 0x0a, 0x37, 0x48, 0x15, 0x58, 0xcb, 0x4f, 0xe7, 0x5b, 0x74, 0xc2, 0x0d, 0xb2, 0x3c, 0x7b, + 0xfb, 0x60, 0x7e, 0xf2, 0xb2, 0x5e, 0x06, 0x9b, 0x2c, 0xd0, 0x75, 0x98, 0xa2, 0x0a, 0xaa, 0x97, + 0x32, 0x1d, 0xef, 0xc7, 0x94, 0x69, 0xa7, 0xd8, 0x28, 0x84, 0x33, 0x4c, 0xd0, 0xab, 0x50, 0xf1, + 0xbd, 0x4d, 0xd2, 0xda, 0x6f, 0xf9, 0xa4, 0x3a, 0xc1, 0x38, 0xe6, 0x2e, 0xab, 0xcb, 0x92, 0x88, + 0x1f, 0x00, 0xd4, 0x5f, 0x9c, 0x16, 0x47, 0x37, 0xe0, 0xbe, 0x84, 0x44, 0xbb, 0x5e, 0xe0, 0xd0, + 0xe5, 0x20, 0xf4, 0x49, 0x66, 0x17, 0x9b, 0x64, 0xf3, 0xed, 0x8c, 0xe8, 0xba, 0xfb, 0xd6, 0x73, + 0xa9, 0x70, 0x41, 0x69, 0x74, 0x0d, 0xa6, 0xd9, 0x4a, 0x68, 0x74, 0x7c, 0xbf, 0x11, 0xfa, 0x5e, + 0x6b, 0xbf, 0x3a, 0xc5, 0x18, 0x7e, 0x4c, 0x1a, 0xbe, 0xea, 0x26, 0x9a, 0x9e, 0x78, 0xd3, 0x7f, + 0x38, 0x5b, 0x1a, 0x6d, 0x30, 0x43, 0x48, 0x27, 0xf2, 0x92, 0x7d, 0x3a, 0x7f, 0xc9, 0xad, 0xa4, + 0x3a, 0xdd, 0xf3, 0xfc, 0xa8, 0x93, 0x2a, 0x6b, 0x89, 0x0e, 0xc4, 0x59, 0x86, 0x74, 0x69, 0xc7, + 0x89, 0xeb, 0x05, 0xd5, 0x19, 0x26, 0x31, 0xd4, 0xca, 0x68, 0x52, 0x20, 0xe6, 0x38, 0x66, 0x04, + 0xa1, 0x3f, 0xae, 0x51, 0x09, 0x3a, 0xcb, 0x08, 0x53, 0x23, 0x88, 0x44, 0xe0, 0x94, 0x86, 0x6e, + 0xcb, 0x49, 0xb2, 0x5f, 0x45, 0x8c, 0x54, 0x2d, 0x97, 0xf5, 0xf5, 0x37, 0x30, 0x85, 0xa3, 0xcb, + 0x30, 0x4a, 0x82, 0xbd, 0xb5, 0x28, 0xdc, 0xad, 0x9e, 0x28, 0x5e, 0xb3, 0xab, 0x9c, 0x84, 0x0b, + 0xf4, 0xf4, 0x00, 0x20, 0xc0, 0x58, 0xb2, 0x40, 0xb7, 0xa0, 0x9a, 0x33, 0x22, 0x7c, 0x00, 0x4e, + 0xb2, 0x01, 0x78, 0x59, 0x94, 0xad, 0xae, 0x17, 0xd0, 0x1d, 0xf6, 0xc0, 0xe1, 0x42, 0xee, 0xf6, + 0x06, 0x4c, 0x29, 0xc1, 0xc2, 0xc6, 0x16, 0xcd, 0xc3, 0x30, 0x95, 0x98, 0xf2, 0x48, 0x5d, 0xa1, + 0x5d, 0xc9, 0x4c, 0x53, 0x98, 0xc3, 0x59, 0x57, 0x7a, 0xef, 0x91, 0xe5, 0xfd, 0x84, 0xf0, 0x63, + 0x51, 0x59, 0xeb, 0x4a, 0x89, 0xc0, 0x29, 0x8d, 0xfd, 0x7f, 0xb9, 0x62, 0x92, 0x4a, 0xaf, 0x01, + 0xe4, 0xf5, 0x53, 0x30, 0xb6, 0x1d, 0xc6, 0x09, 0xa5, 0x66, 0x75, 0x0c, 0xa7, 0xaa, 0xc8, 0x45, + 0x01, 0xc7, 0x8a, 0x02, 0xbd, 0x04, 0x93, 0x2d, 0xbd, 0x02, 0xb1, 0xd9, 0x9c, 0x12, 0x45, 0xcc, + 0xda, 0xb1, 0x49, 0x8b, 0x5e, 0x84, 0x31, 0x76, 0x41, 0xd1, 0x0a, 0x7d, 0x71, 0x00, 0x93, 0x3b, + 0xe6, 0x58, 0x43, 0xc0, 0x0f, 0xb5, 0xdf, 0x58, 0x51, 0xd3, 0x43, 0x31, 0x6d, 0x42, 0xbd, 0x21, + 0xc4, 0xbc, 0x3a, 0x14, 0x5f, 0x64, 0x50, 0x2c, 0xb0, 0xf6, 0xdf, 0x2c, 0x69, 0xbd, 0x4c, 0x8f, + 0x14, 0x04, 0x35, 0x60, 0xf4, 0xa6, 0xe3, 0x25, 0x5e, 0xb0, 0x25, 0xf6, 0xf3, 0xc7, 0x7b, 0xca, + 0x7c, 0x56, 0xe8, 0x75, 0x5e, 0x80, 0xef, 0x4a, 0xe2, 0x0f, 0x96, 0x6c, 0x28, 0xc7, 0xa8, 0x13, + 0x04, 0x94, 0x63, 0x69, 0x50, 0x8e, 0x98, 0x17, 0xe0, 0x1c, 0xc5, 0x1f, 0x2c, 0xd9, 0xa0, 0xb7, + 0x00, 0xe4, 0xbc, 0x21, 0xae, 0xb8, 0x18, 0x78, 0xaa, 0x3f, 0xd3, 0x75, 0x55, 0x66, 0x79, 0x8a, + 0xee, 0x79, 0xe9, 0x7f, 0xac, 0xf1, 0xb3, 0x13, 0xa6, 0xf7, 0x74, 0x37, 0x06, 0x7d, 0x96, 0x2e, + 0x55, 0x27, 0x4a, 0x88, 0xbb, 0x94, 0x88, 0xce, 0x79, 0x62, 0x30, 0xb5, 0x75, 0xdd, 0xdb, 0x25, + 0xfa, 0xb2, 0x16, 0x4c, 0x70, 0xca, 0xcf, 0xfe, 0xed, 0x32, 0x54, 0x8b, 0x9a, 0x4b, 0x27, 0x1d, + 0xb9, 0xe5, 0x25, 0x2b, 0x54, 0x5d, 0xb1, 0xcc, 0x49, 0xb7, 0x2a, 0xe0, 0x58, 0x51, 0xd0, 0xd1, + 0x8f, 0xbd, 0x2d, 0x79, 0xea, 0x18, 0x4e, 0x47, 0xbf, 0xc9, 0xa0, 0x58, 0x60, 0x29, 0x5d, 0x44, + 0x9c, 0x58, 0xdc, 0x3c, 0x69, 0xb3, 0x04, 0x33, 0x28, 0x16, 0x58, 0xdd, 0x60, 0x30, 0xd4, 0xc7, + 0x60, 0x60, 0x74, 0xd1, 0xf0, 0xdd, 0xed, 0x22, 0xf4, 0x36, 0xc0, 0xa6, 0x17, 0x78, 0xf1, 0x36, + 0xe3, 0x3e, 0x72, 0x64, 0xee, 0x4a, 0xd9, 0x59, 0x53, 0x5c, 0xb0, 0xc6, 0x11, 0x3d, 0x0f, 0xe3, + 0x6a, 0x01, 0xd6, 0x6b, 0xd5, 0x51, 0xf3, 0x5a, 0x23, 0x95, 0x46, 0x35, 0xac, 0xd3, 0xd9, 0xef, + 0x64, 0xe7, 0x8b, 0x58, 0x01, 0x5a, 0xff, 0x5a, 0x83, 0xf6, 0x6f, 0xa9, 0x77, 0xff, 0xda, 0x7f, + 0x50, 0x86, 0x69, 0xa3, 0xb2, 0x4e, 0x3c, 0x80, 0xcc, 0xba, 0x40, 0x37, 0x22, 0x27, 0x21, 0x62, + 0xfd, 0xd9, 0xfd, 0x97, 0x8a, 0xbe, 0x59, 0xd1, 0x15, 0xc0, 0xcb, 0xa3, 0xb7, 0xa1, 0xe2, 0x3b, + 0x31, 0x33, 0x3e, 0x10, 0xb1, 0xee, 0x06, 0x61, 0x96, 0x2a, 0xfa, 0x4e, 0x9c, 0x68, 0x7b, 0x01, + 0xe7, 0x9d, 0xb2, 0xa4, 0x3b, 0x26, 0x55, 0x4e, 0xe4, 0xd5, 0xa6, 0x6a, 0x04, 0xd5, 0x60, 0xf6, + 0x31, 0xc7, 0xa1, 0x17, 0x61, 0x22, 0x22, 0x6c, 0x56, 0xac, 0x50, 0x5d, 0x8b, 0x4d, 0xb3, 0xe1, + 0x54, 0x29, 0xc3, 0x1a, 0x0e, 0x1b, 0x94, 0xa9, 0xae, 0x3d, 0xd2, 0x43, 0xd7, 0x7e, 0x1c, 0x46, + 0xd9, 0x0f, 0x35, 0x03, 0xd4, 0x68, 0xd4, 0x39, 0x18, 0x4b, 0x7c, 0x76, 0xc2, 0x8c, 0x0d, 0x38, + 0x61, 0x9e, 0x80, 0xa9, 0x9a, 0x43, 0x76, 0xc3, 0x60, 0x35, 0x70, 0xdb, 0xa1, 0x17, 0x24, 0xa8, + 0x0a, 0x43, 0x6c, 0x77, 0xe0, 0x6b, 0x7b, 0x88, 0x72, 0xc0, 0x43, 0x54, 0x73, 0xb6, 0xff, 0xa8, + 0x04, 0x93, 0x35, 0xe2, 0x93, 0x84, 0xf0, 0xb3, 0x46, 0x8c, 0xd6, 0x00, 0x6d, 0x45, 0x4e, 0x8b, + 0x34, 0x48, 0xe4, 0x85, 0xae, 0x6e, 0x8c, 0x2c, 0x33, 0x83, 0x3f, 0xba, 0xd0, 0x85, 0xc5, 0x39, + 0x25, 0xd0, 0x9b, 0x30, 0xd9, 0x8e, 0x88, 0x61, 0x43, 0xb3, 0x8a, 0xd4, 0x85, 0x86, 0x4e, 0xc8, + 0x35, 0x55, 0x03, 0x84, 0x4d, 0x56, 0xe8, 0x33, 0x30, 0x13, 0x46, 0xed, 0x6d, 0x27, 0xa8, 0x91, + 0x36, 0x09, 0x5c, 0xaa, 0x8a, 0x0b, 0x1b, 0xc1, 0xc9, 0xdb, 0x07, 0xf3, 0x33, 0xd7, 0x32, 0x38, + 0xdc, 0x45, 0x8d, 0xde, 0x84, 0xd9, 0x76, 0x14, 0xb6, 0x9d, 0x2d, 0x36, 0x51, 0x84, 0xc6, 0xc1, + 0xa5, 0xcf, 0x53, 0xb7, 0x0f, 0xe6, 0x67, 0x1b, 0x59, 0xe4, 0xe1, 0xc1, 0xfc, 0x09, 0xd6, 0x51, + 0x14, 0x92, 0x22, 0x71, 0x37, 0x1b, 0x7b, 0x0b, 0x4e, 0xd5, 0xc2, 0x9b, 0xc1, 0x4d, 0x27, 0x72, + 0x97, 0x1a, 0x75, 0xed, 0x70, 0x7f, 0x55, 0x1e, 0x2e, 0xf9, 0xf5, 0x6b, 0xee, 0x3e, 0xa5, 0x95, + 0xe4, 0xea, 0xff, 0x9a, 0xe7, 0x93, 0x02, 0x23, 0xc2, 0xdf, 0x2e, 0x19, 0x35, 0xa5, 0xf4, 0xca, + 0xee, 0x6f, 0x15, 0xda, 0xfd, 0x5f, 0x83, 0xb1, 0x4d, 0x8f, 0xf8, 0x2e, 0x26, 0x9b, 0x62, 0x64, + 0x1e, 0x2b, 0xbe, 0x51, 0x5a, 0xa3, 0x94, 0xd2, 0x68, 0xc4, 0x8f, 0xa6, 0x6b, 0xa2, 0x30, 0x56, + 0x6c, 0xd0, 0x0e, 0xcc, 0xc8, 0xb3, 0x8f, 0xc4, 0x8a, 0x45, 0xfc, 0x78, 0xaf, 0x03, 0x95, 0xc9, + 0x9c, 0x0d, 0x20, 0xce, 0xb0, 0xc1, 0x5d, 0x8c, 0xe9, 0x59, 0x74, 0x97, 0x6e, 0x57, 0x43, 0x6c, + 0x4a, 0xb3, 0xb3, 0x28, 0x3b, 0x56, 0x33, 0xa8, 0xfd, 0x55, 0x0b, 0xee, 0xef, 0xea, 0x19, 0x61, + 0x5e, 0xb8, 0xcb, 0xa3, 0x90, 0x3d, 0xee, 0x97, 0xfa, 0x1f, 0xf7, 0xed, 0x5f, 0xb7, 0xe0, 0xe4, + 0xea, 0x6e, 0x3b, 0xd9, 0xaf, 0x79, 0xe6, 0xdd, 0xc4, 0x0b, 0x30, 0xb2, 0x4b, 0x5c, 0xaf, 0xb3, + 0x2b, 0x46, 0x6e, 0x5e, 0x8a, 0xf4, 0x2b, 0x0c, 0x7a, 0x78, 0x30, 0x3f, 0xd9, 0x4c, 0xc2, 0xc8, + 0xd9, 0x22, 0x1c, 0x80, 0x05, 0x39, 0xfa, 0x69, 0xae, 0x9b, 0x5e, 0xf6, 0x76, 0x3d, 0x79, 0x43, + 0xd8, 0xd3, 0xe4, 0xb5, 0x20, 0x3b, 0x74, 0xe1, 0xb5, 0x8e, 0x13, 0x24, 0x5e, 0xb2, 0x6f, 0xea, + 0xb2, 0x8c, 0x11, 0x4e, 0x79, 0xda, 0xdf, 0xb5, 0x60, 0x5a, 0xca, 0x93, 0x25, 0xd7, 0x8d, 0x48, + 0x1c, 0xa3, 0x39, 0x28, 0x79, 0x6d, 0xd1, 0x52, 0x10, 0xa5, 0x4b, 0xf5, 0x06, 0x2e, 0x79, 0x6d, + 0xd4, 0x80, 0x0a, 0xbf, 0x6c, 0x4c, 0x27, 0xd8, 0x40, 0x57, 0x96, 0xec, 0xec, 0xb7, 0x2e, 0x4b, + 0xe2, 0x94, 0x89, 0xd4, 0x8c, 0xd9, 0x5e, 0x54, 0x36, 0xef, 0x6d, 0x2e, 0x0a, 0x38, 0x56, 0x14, + 0xe8, 0x1c, 0x8c, 0x05, 0xa1, 0xcb, 0xef, 0x7e, 0xf9, 0xba, 0x66, 0xd3, 0xf6, 0xaa, 0x80, 0x61, + 0x85, 0xb5, 0x7f, 0xce, 0x82, 0x09, 0xf9, 0x65, 0x03, 0x2a, 0xe9, 0x74, 0x79, 0xa5, 0x0a, 0x7a, + 0xba, 0xbc, 0xa8, 0x92, 0xcd, 0x30, 0x86, 0x6e, 0x5d, 0x3e, 0x8a, 0x6e, 0x6d, 0x7f, 0xa5, 0x04, + 0x53, 0xb2, 0x39, 0xcd, 0xce, 0x46, 0x4c, 0x12, 0xb4, 0x0e, 0x15, 0x87, 0x77, 0x39, 0x91, 0xb3, + 0xf6, 0x91, 0xfc, 0x53, 0x97, 0x31, 0x3e, 0xe9, 0x88, 0x2e, 0xc9, 0xd2, 0x38, 0x65, 0x84, 0x7c, + 0x98, 0x0d, 0xc2, 0x84, 0x6d, 0x7d, 0x0a, 0xdf, 0xeb, 0x6e, 0x20, 0xcb, 0xfd, 0xb4, 0xe0, 0x3e, + 0x7b, 0x35, 0xcb, 0x05, 0x77, 0x33, 0x46, 0xab, 0xd2, 0xd2, 0x53, 0x66, 0x35, 0x9c, 0xed, 0x55, + 0x43, 0xb1, 0xa1, 0xc7, 0xfe, 0x3d, 0x0b, 0x2a, 0x92, 0xec, 0x38, 0xae, 0x81, 0xae, 0xc0, 0x68, + 0xcc, 0x06, 0x41, 0x76, 0x8d, 0xdd, 0xab, 0xe1, 0x7c, 0xbc, 0xd2, 0x1d, 0x9d, 0xff, 0x8f, 0xb1, + 0xe4, 0xc1, 0x4c, 0xd5, 0xaa, 0xf9, 0x1f, 0x12, 0x53, 0xb5, 0x6a, 0x4f, 0xc1, 0x2e, 0xf3, 0x5f, + 0x59, 0x9b, 0xb5, 0xf3, 0x3c, 0x55, 0x3c, 0xdb, 0x11, 0xd9, 0xf4, 0x6e, 0x65, 0x15, 0xcf, 0x06, + 0x83, 0x62, 0x81, 0x45, 0x6f, 0xc1, 0x44, 0x4b, 0x5a, 0x78, 0x53, 0x31, 0xf0, 0x68, 0x4f, 0x7b, + 0xb9, 0xba, 0x5a, 0xe1, 0x7e, 0x61, 0x2b, 0x5a, 0x79, 0x6c, 0x70, 0x33, 0x2f, 0xe7, 0xcb, 0xfd, + 0x2e, 0xe7, 0x53, 0xbe, 0x85, 0xd7, 0xcb, 0xf6, 0x2f, 0x5b, 0x30, 0xc2, 0xed, 0x84, 0x83, 0x19, + 0x56, 0xb5, 0xab, 0xa2, 0xb4, 0xef, 0x6e, 0x50, 0xa0, 0xb8, 0x39, 0x42, 0x57, 0xa0, 0xc2, 0x7e, + 0x30, 0x7b, 0x49, 0xb9, 0xd8, 0x21, 0x8e, 0xd7, 0xaa, 0x37, 0xf0, 0x86, 0x2c, 0x86, 0x53, 0x0e, + 0xf6, 0x2f, 0x94, 0xa9, 0xa8, 0x4a, 0x49, 0x8d, 0x5d, 0xdc, 0xba, 0x77, 0xbb, 0x78, 0xe9, 0x5e, + 0xed, 0xe2, 0x5b, 0x30, 0xdd, 0xd2, 0xee, 0xa5, 0xd2, 0x91, 0x3c, 0xd7, 0x73, 0x92, 0x68, 0x57, + 0x58, 0xdc, 0x56, 0xb6, 0x62, 0x32, 0xc1, 0x59, 0xae, 0xe8, 0xb3, 0x30, 0xc1, 0xc7, 0x59, 0xd4, + 0x32, 0xc4, 0x6a, 0xf9, 0x58, 0xf1, 0x7c, 0xd1, 0xab, 0x60, 0x33, 0xb1, 0xa9, 0x15, 0xc7, 0x06, + 0x33, 0xfb, 0x4b, 0xc3, 0x30, 0xbc, 0xba, 0x47, 0x82, 0xe4, 0x18, 0x04, 0x52, 0x0b, 0xa6, 0xbc, + 0x60, 0x2f, 0xf4, 0xf7, 0x88, 0xcb, 0xf1, 0x47, 0xd9, 0x5c, 0xef, 0x13, 0xac, 0xa7, 0xea, 0x06, + 0x0b, 0x9c, 0x61, 0x79, 0x2f, 0x4e, 0xee, 0x17, 0x60, 0x84, 0x8f, 0xbd, 0x38, 0xb6, 0xe7, 0x5a, + 0xc1, 0x59, 0x27, 0x8a, 0x55, 0x90, 0x5a, 0x15, 0xb8, 0xd9, 0x5d, 0x14, 0x47, 0xef, 0xc0, 0xd4, + 0xa6, 0x17, 0xc5, 0x09, 0x3d, 0x72, 0xc7, 0x89, 0xb3, 0xdb, 0xbe, 0x83, 0x93, 0xba, 0xea, 0x87, + 0x35, 0x83, 0x13, 0xce, 0x70, 0x46, 0x5b, 0x30, 0x49, 0x0f, 0x8f, 0x69, 0x55, 0xa3, 0x47, 0xae, + 0x4a, 0x99, 0xe2, 0x2e, 0xeb, 0x8c, 0xb0, 0xc9, 0x97, 0x0a, 0x93, 0x16, 0x3b, 0x6c, 0x8e, 0x31, + 0x8d, 0x42, 0x09, 0x13, 0x7e, 0xca, 0xe4, 0x38, 0x2a, 0x93, 0x98, 0x3f, 0x47, 0xc5, 0x94, 0x49, + 0xa9, 0xd7, 0x86, 0xfd, 0x35, 0xba, 0x3b, 0xd2, 0x3e, 0x3c, 0x86, 0xad, 0xe5, 0x15, 0x73, 0x6b, + 0x39, 0x5d, 0x38, 0x9e, 0x05, 0xdb, 0xca, 0xe7, 0x60, 0x5c, 0x1b, 0x6e, 0xb4, 0x08, 0x95, 0x96, + 0x74, 0x3e, 0x10, 0x52, 0x57, 0xa9, 0x2f, 0xca, 0x2b, 0x01, 0xa7, 0x34, 0xb4, 0x37, 0xa8, 0xb2, + 0x97, 0x75, 0x6d, 0xa2, 0xaa, 0x20, 0x66, 0x18, 0xfb, 0x59, 0x80, 0xd5, 0x5b, 0xa4, 0xb5, 0xc4, + 0x0f, 0x5f, 0xda, 0x1d, 0x97, 0x55, 0x7c, 0xc7, 0x65, 0xff, 0x07, 0x0b, 0xa6, 0xd6, 0x56, 0x0c, + 0xa5, 0x7c, 0x01, 0x80, 0x6b, 0xa1, 0xaf, 0xbf, 0x7e, 0x55, 0x5a, 0x87, 0xb9, 0x81, 0x4f, 0x41, + 0xb1, 0x46, 0x81, 0x4e, 0x43, 0xd9, 0xef, 0x04, 0x42, 0x39, 0x1c, 0xbd, 0x7d, 0x30, 0x5f, 0xbe, + 0xdc, 0x09, 0x30, 0x85, 0x69, 0xde, 0x44, 0xe5, 0x81, 0xbd, 0x89, 0xfa, 0xba, 0x61, 0xa3, 0x79, + 0x18, 0xbe, 0x79, 0xd3, 0x73, 0xe3, 0xea, 0x70, 0x6a, 0xb9, 0x7e, 0xfd, 0xf5, 0x7a, 0x2d, 0xc6, + 0x1c, 0x6e, 0xff, 0xe5, 0x32, 0xcc, 0xac, 0xf9, 0xe4, 0x96, 0xf1, 0x59, 0x8f, 0xc2, 0x88, 0x1b, + 0x79, 0x7b, 0x24, 0xca, 0xee, 0xe2, 0x35, 0x06, 0xc5, 0x02, 0x3b, 0xb0, 0x07, 0xd4, 0xf5, 0xee, + 0xfd, 0xf8, 0x6e, 0xfb, 0x7c, 0xf5, 0xef, 0x8a, 0xb7, 0x60, 0x94, 0x5f, 0x95, 0xf2, 0xce, 0x18, + 0x3f, 0xff, 0x4c, 0x5e, 0x13, 0xb2, 0x7d, 0xb1, 0x20, 0x8c, 0x1f, 0xdc, 0x6f, 0x44, 0x09, 0x31, + 0x01, 0xc5, 0x92, 0xe5, 0xdc, 0x27, 0x61, 0x42, 0xa7, 0x3c, 0x92, 0x03, 0xc9, 0x5f, 0xb1, 0xe0, + 0xc4, 0x9a, 0x1f, 0xb6, 0x76, 0x32, 0xee, 0x68, 0xcf, 0xc3, 0x38, 0x5d, 0x4f, 0xb1, 0xe1, 0xda, + 0x6a, 0x38, 0x3b, 0x0b, 0x14, 0xd6, 0xe9, 0xb4, 0x62, 0xd7, 0xaf, 0xd7, 0x6b, 0x79, 0x3e, 0xd2, + 0x02, 0x85, 0x75, 0x3a, 0xfb, 0x3b, 0x16, 0x3c, 0x74, 0x61, 0x65, 0x35, 0xf5, 0xc8, 0xec, 0x72, + 0xd3, 0xa6, 0xca, 0x9d, 0xab, 0x35, 0x25, 0x55, 0xee, 0x6a, 0xac, 0x15, 0x02, 0xfb, 0x61, 0x09, + 0x41, 0xf8, 0x55, 0x0b, 0x4e, 0x5c, 0xf0, 0x12, 0x4c, 0xda, 0x61, 0xd6, 0x61, 0x38, 0x22, 0xed, + 0x30, 0xf6, 0x92, 0x30, 0xda, 0xcf, 0x3a, 0x0c, 0x63, 0x85, 0xc1, 0x1a, 0x15, 0xaf, 0x79, 0xcf, + 0x8b, 0x69, 0x4b, 0x4b, 0xe6, 0x09, 0x13, 0x0b, 0x38, 0x56, 0x14, 0xf4, 0xc3, 0x5c, 0x2f, 0x62, + 0x1a, 0xc2, 0xbe, 0x58, 0xce, 0xea, 0xc3, 0x6a, 0x12, 0x81, 0x53, 0x1a, 0xfb, 0xab, 0x16, 0x9c, + 0xba, 0xe0, 0x77, 0xe2, 0x84, 0x44, 0x9b, 0xb1, 0xd1, 0xd8, 0x67, 0xa1, 0x42, 0xa4, 0x16, 0x2e, + 0xda, 0xaa, 0xf6, 0x0d, 0xa5, 0x9e, 0x73, 0x6f, 0x65, 0x45, 0x37, 0x80, 0x6f, 0xe7, 0xd1, 0x7c, + 0x12, 0xbf, 0x5e, 0x82, 0xc9, 0x8b, 0xeb, 0xeb, 0x8d, 0x0b, 0x24, 0x11, 0x22, 0xb3, 0xbf, 0x15, + 0x09, 0x6b, 0x07, 0xe1, 0x5e, 0xba, 0x4e, 0x27, 0xf1, 0xfc, 0x05, 0x1e, 0x1e, 0xb3, 0x50, 0x0f, + 0x92, 0x6b, 0x51, 0x33, 0x89, 0xbc, 0x60, 0x2b, 0xf7, 0xe8, 0x2c, 0x05, 0x7b, 0xb9, 0x48, 0xb0, + 0xa3, 0x67, 0x61, 0x84, 0xc5, 0xe7, 0x48, 0xad, 0xe3, 0x01, 0xa5, 0x2a, 0x30, 0xe8, 0xe1, 0xc1, + 0x7c, 0xe5, 0x3a, 0xae, 0xf3, 0x3f, 0x58, 0x90, 0xa2, 0xeb, 0x30, 0xbe, 0x9d, 0x24, 0xed, 0x8b, + 0xc4, 0x71, 0x49, 0x24, 0xa5, 0xc3, 0x99, 0x3c, 0xe9, 0x40, 0x3b, 0x81, 0x93, 0xa5, 0x0b, 0x2a, + 0x85, 0xc5, 0x58, 0xe7, 0x63, 0x37, 0x01, 0x52, 0xdc, 0x5d, 0x3a, 0x36, 0xd8, 0x3f, 0xb0, 0x60, + 0xf4, 0xa2, 0x13, 0xb8, 0x3e, 0x89, 0xd0, 0xcb, 0x30, 0x44, 0x6e, 0x91, 0x96, 0xd8, 0xc1, 0x73, + 0x1b, 0x9c, 0xee, 0x72, 0xdc, 0x10, 0x46, 0xff, 0x63, 0x56, 0x0a, 0x5d, 0x84, 0x51, 0xda, 0xda, + 0x0b, 0xca, 0x6f, 0xfc, 0xe1, 0xa2, 0x2f, 0x56, 0xc3, 0xce, 0x37, 0x46, 0x01, 0xc2, 0xb2, 0x38, + 0x33, 0xe8, 0xb4, 0xda, 0x4d, 0x2a, 0xc0, 0x92, 0x5e, 0xc7, 0xad, 0xf5, 0x95, 0x06, 0x27, 0x12, + 0xdc, 0xb8, 0x41, 0x47, 0x02, 0x71, 0xca, 0xc4, 0x5e, 0x87, 0x0a, 0x1d, 0xd4, 0x25, 0xdf, 0x73, + 0x7a, 0xdb, 0x92, 0x9e, 0x84, 0x8a, 0xb4, 0xeb, 0xc4, 0xc2, 0xf5, 0x9c, 0x71, 0x95, 0x66, 0x9f, + 0x18, 0xa7, 0x78, 0x7b, 0x13, 0x4e, 0xb2, 0x8b, 0x52, 0x27, 0xd9, 0x36, 0xd6, 0x58, 0xff, 0xc9, + 0xfc, 0x94, 0xd0, 0xaf, 0xf8, 0xc8, 0x54, 0x35, 0x5f, 0xd9, 0x09, 0xc9, 0x51, 0xd3, 0xb5, 0xfe, + 0xf3, 0x10, 0xcc, 0xd6, 0x9b, 0x2b, 0x4d, 0xd3, 0xb8, 0xf8, 0x22, 0x4c, 0x70, 0x4d, 0x80, 0x4e, + 0x68, 0xc7, 0x17, 0xb5, 0xa9, 0xcb, 0x83, 0x75, 0x0d, 0x87, 0x0d, 0x4a, 0xf4, 0x10, 0x94, 0xbd, + 0x77, 0x83, 0xac, 0x3b, 0x5c, 0xfd, 0xb5, 0xab, 0x98, 0xc2, 0x29, 0x9a, 0x2a, 0x15, 0x5c, 0x80, + 0x2a, 0xb4, 0x52, 0x2c, 0x5e, 0x81, 0x29, 0x2f, 0x6e, 0xc5, 0x5e, 0x3d, 0xa0, 0xd2, 0x25, 0x8d, + 0xbb, 0x48, 0x35, 0x7e, 0xda, 0x54, 0x85, 0xc5, 0x19, 0x6a, 0x4d, 0x9a, 0x0f, 0x0f, 0xac, 0x98, + 0xf4, 0xf5, 0xc0, 0xa6, 0x3a, 0x57, 0x9b, 0x7d, 0x5d, 0xcc, 0x5c, 0x73, 0x84, 0xce, 0xc5, 0x3f, + 0x38, 0xc6, 0x12, 0x87, 0x2e, 0xc0, 0x6c, 0x6b, 0xdb, 0x69, 0x2f, 0x75, 0x92, 0xed, 0x9a, 0x17, + 0xb7, 0xc2, 0x3d, 0x12, 0xed, 0x33, 0x4d, 0x78, 0x2c, 0x35, 0x32, 0x29, 0xc4, 0xca, 0xc5, 0xa5, + 0x06, 0xa5, 0xc4, 0xdd, 0x65, 0x4c, 0x15, 0x04, 0xee, 0x9a, 0x0a, 0xb2, 0x04, 0xd3, 0xb2, 0xae, + 0x26, 0x89, 0xd9, 0xf6, 0x30, 0xce, 0x5a, 0xa7, 0xc2, 0xa2, 0x04, 0x58, 0xb5, 0x2d, 0x4b, 0x8f, + 0x5e, 0x80, 0x49, 0x2f, 0xf0, 0x12, 0xcf, 0x49, 0xc2, 0x88, 0x6d, 0xae, 0x13, 0x7c, 0xc3, 0xa0, + 0x12, 0xbe, 0xae, 0x23, 0xb0, 0x49, 0x67, 0xbf, 0x03, 0x15, 0xe5, 0x6f, 0x26, 0x5d, 0x26, 0xad, + 0x02, 0x97, 0xc9, 0xfe, 0x3b, 0x82, 0xb4, 0x9a, 0x97, 0x73, 0xad, 0xe6, 0x7f, 0xc7, 0x82, 0xd4, + 0xed, 0x06, 0x5d, 0x84, 0x4a, 0x3b, 0x64, 0x37, 0x67, 0x91, 0xbc, 0x8e, 0x7e, 0x20, 0x57, 0x78, + 0x70, 0x41, 0xc5, 0xfb, 0xaf, 0x21, 0x4b, 0xe0, 0xb4, 0x30, 0x5a, 0x86, 0xd1, 0x76, 0x44, 0x9a, + 0x09, 0x0b, 0x1c, 0xe9, 0xcb, 0x87, 0xcf, 0x11, 0x4e, 0x8f, 0x65, 0x41, 0xfb, 0x37, 0x2d, 0x00, + 0x6e, 0x94, 0x76, 0x82, 0x2d, 0x72, 0x0c, 0x07, 0xed, 0x1a, 0x0c, 0xc5, 0x6d, 0xd2, 0xea, 0x75, + 0xa7, 0x99, 0xb6, 0xa7, 0xd9, 0x26, 0xad, 0xb4, 0xc3, 0xe9, 0x3f, 0xcc, 0x4a, 0xdb, 0x3f, 0x0b, + 0x30, 0x95, 0x92, 0xd1, 0x03, 0x10, 0x7a, 0xda, 0x70, 0xcb, 0x3f, 0x9d, 0x71, 0xcb, 0xaf, 0x30, + 0x6a, 0xcd, 0x13, 0xff, 0x1d, 0x28, 0xef, 0x3a, 0xb7, 0xc4, 0x29, 0xeb, 0xc9, 0xde, 0xcd, 0xa0, + 0xfc, 0x17, 0xae, 0x38, 0xb7, 0xb8, 0x1e, 0xfb, 0xa4, 0x9c, 0x20, 0x57, 0x9c, 0x5b, 0x87, 0xfc, + 0xe6, 0x92, 0x09, 0x29, 0x7a, 0x98, 0xfb, 0xc2, 0x1f, 0xa7, 0xff, 0xd9, 0xb4, 0xa3, 0x95, 0xb0, + 0xba, 0xbc, 0x40, 0x98, 0x68, 0x07, 0xaa, 0xcb, 0x0b, 0xb2, 0x75, 0x79, 0xc1, 0x00, 0x75, 0x79, + 0x01, 0x7a, 0x0f, 0x46, 0xc5, 0x95, 0x08, 0xf3, 0x27, 0x1c, 0x3f, 0xbf, 0x38, 0x40, 0x7d, 0xe2, + 0x46, 0x85, 0xd7, 0xb9, 0x28, 0xf5, 0x74, 0x01, 0xed, 0x5b, 0xaf, 0xac, 0x10, 0xfd, 0x2d, 0x0b, + 0xa6, 0xc4, 0x6f, 0x4c, 0xde, 0xed, 0x90, 0x38, 0x11, 0xfa, 0xc0, 0x27, 0x06, 0x6f, 0x83, 0x28, + 0xc8, 0x9b, 0xf2, 0x09, 0x29, 0x66, 0x4d, 0x64, 0xdf, 0x16, 0x65, 0x5a, 0x81, 0xfe, 0xa9, 0x05, + 0x27, 0x77, 0x9d, 0x5b, 0xbc, 0x46, 0x0e, 0xc3, 0x4e, 0xe2, 0x85, 0xc2, 0x3f, 0xf2, 0xe5, 0xc1, + 0x86, 0xbf, 0xab, 0x38, 0x6f, 0xa4, 0x74, 0xa5, 0x3a, 0x99, 0x47, 0xd2, 0xb7, 0xa9, 0xb9, 0xed, + 0x9a, 0xdb, 0x84, 0x31, 0x39, 0xdf, 0x72, 0x4e, 0x43, 0x35, 0x5d, 0xd9, 0x39, 0xf2, 0x8d, 0x94, + 0x76, 0x7a, 0x62, 0xf5, 0x88, 0xb9, 0x76, 0x4f, 0xeb, 0x79, 0x07, 0x26, 0xf4, 0x39, 0x76, 0x4f, + 0xeb, 0x7a, 0x17, 0x4e, 0xe4, 0xcc, 0xa5, 0x7b, 0x5a, 0xe5, 0x4d, 0x38, 0x5d, 0x38, 0x3f, 0xee, + 0x65, 0xc5, 0xf6, 0xd7, 0x2d, 0x5d, 0x0e, 0x1e, 0x83, 0x79, 0x6a, 0xc5, 0x34, 0x4f, 0x9d, 0xe9, + 0xbd, 0x72, 0x0a, 0x6c, 0x54, 0x6f, 0xe9, 0x8d, 0xa6, 0x52, 0x1d, 0xbd, 0x0a, 0x23, 0x3e, 0x85, + 0xc8, 0x7b, 0x38, 0xbb, 0xff, 0x8a, 0x4c, 0x75, 0x29, 0x06, 0x8f, 0xb1, 0xe0, 0x60, 0xff, 0x8e, + 0x05, 0x43, 0xc7, 0xd0, 0x13, 0xd8, 0xec, 0x89, 0xa7, 0x0b, 0x59, 0x8b, 0xdc, 0x07, 0x0b, 0xd8, + 0xb9, 0xb9, 0x2a, 0xf3, 0x3b, 0x14, 0x74, 0xcc, 0xff, 0x29, 0xc1, 0x38, 0xad, 0x4a, 0x3a, 0x8d, + 0xbc, 0x04, 0x93, 0xbe, 0xb3, 0x41, 0x7c, 0x69, 0x32, 0xcf, 0x1e, 0x62, 0x2f, 0xeb, 0x48, 0x6c, + 0xd2, 0xd2, 0xc2, 0x9b, 0xfa, 0xed, 0x81, 0xd0, 0x5f, 0x54, 0x61, 0xe3, 0x6a, 0x01, 0x9b, 0xb4, + 0xf4, 0x3c, 0x75, 0xd3, 0x49, 0x5a, 0xdb, 0xe2, 0x80, 0xab, 0x9a, 0xfb, 0x3a, 0x05, 0x62, 0x8e, + 0xa3, 0x0a, 0x9c, 0x9c, 0x9d, 0x37, 0x48, 0xc4, 0x14, 0x38, 0xae, 0x1e, 0x2b, 0x05, 0x0e, 0x9b, + 0x68, 0x9c, 0xa5, 0xcf, 0x89, 0xcf, 0x1b, 0x66, 0x2e, 0x31, 0x03, 0xc4, 0xe7, 0xa1, 0x06, 0x9c, + 0xf4, 0x82, 0x96, 0xdf, 0x71, 0xc9, 0xf5, 0x80, 0x6b, 0x77, 0xbe, 0xf7, 0x1e, 0x71, 0x85, 0x02, + 0xad, 0xbc, 0x97, 0xea, 0x39, 0x34, 0x38, 0xb7, 0xa4, 0xfd, 0xd3, 0x70, 0xe2, 0x72, 0xe8, 0xb8, + 0xcb, 0x8e, 0xef, 0x04, 0x2d, 0x12, 0xd5, 0x83, 0xad, 0xbe, 0x17, 0xf2, 0xfa, 0xf5, 0x79, 0xa9, + 0xdf, 0xf5, 0xb9, 0xbd, 0x0d, 0x48, 0xaf, 0x40, 0xb8, 0x82, 0x61, 0x18, 0xf5, 0x78, 0x55, 0x62, + 0xfa, 0x3f, 0x96, 0xaf, 0x5d, 0x77, 0xb5, 0x4c, 0x73, 0x72, 0xe2, 0x00, 0x2c, 0x19, 0xd9, 0x2f, + 0x42, 0x6e, 0x7c, 0x46, 0xff, 0xa3, 0xb4, 0xfd, 0x3c, 0xcc, 0xb2, 0x92, 0x47, 0x3b, 0xe6, 0xd9, + 0x7f, 0xdd, 0x82, 0xe9, 0xab, 0x99, 0x88, 0xda, 0x47, 0x61, 0x84, 0x67, 0x39, 0xc9, 0x1a, 0xbd, + 0x9a, 0x0c, 0x8a, 0x05, 0xf6, 0xae, 0xdb, 0x5c, 0x7e, 0x68, 0x41, 0x45, 0x85, 0xbf, 0x1f, 0x83, + 0x52, 0xbb, 0x62, 0x28, 0xb5, 0xb9, 0xb6, 0x00, 0xd5, 0x9c, 0x22, 0x9d, 0x16, 0x5d, 0x52, 0xb1, + 0xa1, 0x3d, 0xcc, 0x00, 0x29, 0x1b, 0x1e, 0x49, 0x38, 0x65, 0x06, 0x90, 0xca, 0x68, 0x51, 0x76, + 0x23, 0xae, 0x68, 0x3f, 0x24, 0x37, 0xe2, 0xaa, 0x3d, 0x05, 0xd2, 0xaf, 0xa1, 0x35, 0x99, 0xed, + 0x0a, 0x9f, 0x66, 0x9e, 0xa3, 0x6c, 0x6d, 0xaa, 0x90, 0xec, 0x79, 0xe1, 0x09, 0x2a, 0xa0, 0x87, + 0x4c, 0x90, 0x89, 0x7f, 0x3c, 0x55, 0x41, 0x5a, 0xc4, 0xbe, 0x08, 0xd3, 0x99, 0x0e, 0x43, 0xcf, + 0xc3, 0x70, 0x7b, 0xdb, 0x89, 0x49, 0xc6, 0x13, 0x68, 0xb8, 0x41, 0x81, 0x87, 0x07, 0xf3, 0x53, + 0xaa, 0x00, 0x83, 0x60, 0x4e, 0x6d, 0xff, 0x0f, 0x0b, 0x86, 0xae, 0x86, 0xee, 0x71, 0x4c, 0xa6, + 0x57, 0x8c, 0xc9, 0xf4, 0x60, 0x51, 0xa2, 0x97, 0xc2, 0x79, 0xb4, 0x96, 0x99, 0x47, 0x67, 0x0a, + 0x39, 0xf4, 0x9e, 0x42, 0xbb, 0x30, 0xce, 0xd2, 0xc7, 0x08, 0xaf, 0xa4, 0x67, 0x8d, 0xf3, 0xd5, + 0x7c, 0xe6, 0x7c, 0x35, 0xad, 0x91, 0x6a, 0xa7, 0xac, 0xc7, 0x61, 0x54, 0x78, 0xc6, 0x64, 0x7d, + 0x64, 0x05, 0x2d, 0x96, 0x78, 0xfb, 0x97, 0xcb, 0x60, 0xa4, 0xab, 0x41, 0xbf, 0x67, 0xc1, 0x42, + 0xc4, 0xa3, 0x82, 0xdc, 0x5a, 0x27, 0xf2, 0x82, 0xad, 0x66, 0x6b, 0x9b, 0xb8, 0x1d, 0xdf, 0x0b, + 0xb6, 0xea, 0x5b, 0x41, 0xa8, 0xc0, 0xab, 0xb7, 0x48, 0xab, 0xc3, 0xec, 0xe0, 0x7d, 0x72, 0xe3, + 0xa8, 0x9b, 0xe7, 0xf3, 0xb7, 0x0f, 0xe6, 0x17, 0xf0, 0x91, 0x78, 0xe3, 0x23, 0xb6, 0x05, 0x7d, + 0xc7, 0x82, 0x45, 0x9e, 0xc5, 0x65, 0xf0, 0xf6, 0xf7, 0x38, 0x8d, 0x36, 0x24, 0xab, 0x94, 0xc9, + 0x3a, 0x89, 0x76, 0x97, 0x5f, 0x10, 0x1d, 0xba, 0xd8, 0x38, 0x5a, 0x5d, 0xf8, 0xa8, 0x8d, 0xb3, + 0xff, 0x55, 0x19, 0x26, 0x69, 0x2f, 0xa6, 0x91, 0xf0, 0xcf, 0x1b, 0x53, 0xe2, 0xe1, 0xcc, 0x94, + 0x98, 0x35, 0x88, 0xef, 0x4e, 0x10, 0x7c, 0x0c, 0xb3, 0xbe, 0x13, 0x27, 0x17, 0x89, 0x13, 0x25, + 0x1b, 0xc4, 0x61, 0x57, 0xbd, 0x62, 0x9a, 0x1f, 0xe5, 0xf6, 0x58, 0x99, 0xbf, 0x2e, 0x67, 0x99, + 0xe1, 0x6e, 0xfe, 0x68, 0x0f, 0x10, 0xbb, 0x56, 0x8e, 0x9c, 0x20, 0xe6, 0xdf, 0xe2, 0x09, 0x1b, + 0xf9, 0xd1, 0x6a, 0x9d, 0x13, 0xb5, 0xa2, 0xcb, 0x5d, 0xdc, 0x70, 0x4e, 0x0d, 0x9a, 0xbb, 0xc0, + 0xf0, 0xa0, 0xee, 0x02, 0x23, 0x7d, 0x1c, 0xd1, 0x77, 0x61, 0x46, 0x8c, 0xca, 0xa6, 0xb7, 0x25, + 0x36, 0xe9, 0x37, 0x32, 0xee, 0x44, 0xd6, 0xe0, 0x8e, 0x0f, 0x7d, 0x7c, 0x89, 0xec, 0x9f, 0x81, + 0x13, 0xb4, 0x3a, 0xd3, 0x6d, 0x3a, 0x46, 0x04, 0xa6, 0x77, 0x3a, 0x1b, 0xc4, 0x27, 0x89, 0x84, + 0x89, 0x4a, 0x73, 0xd5, 0x7e, 0xb3, 0x74, 0xaa, 0x5b, 0x5e, 0x32, 0x59, 0xe0, 0x2c, 0x4f, 0xfb, + 0x57, 0x2c, 0x60, 0x8e, 0x89, 0xc7, 0xb0, 0xfd, 0x7d, 0xca, 0xdc, 0xfe, 0xaa, 0x45, 0x12, 0xa8, + 0x60, 0xe7, 0x7b, 0x8e, 0x0f, 0x4b, 0x23, 0x0a, 0x6f, 0xed, 0x4b, 0xdd, 0xbf, 0xbf, 0xc6, 0xf5, + 0xbf, 0x2d, 0xbe, 0x20, 0x55, 0x90, 0x24, 0xfa, 0x3c, 0x8c, 0xb5, 0x9c, 0xb6, 0xd3, 0xe2, 0x79, + 0xc2, 0x0a, 0xad, 0x3f, 0x46, 0xa1, 0x85, 0x15, 0x51, 0x82, 0x5b, 0x33, 0x3e, 0x2e, 0xbf, 0x52, + 0x82, 0xfb, 0x5a, 0x30, 0x54, 0x95, 0x73, 0x3b, 0x30, 0x69, 0x30, 0xbb, 0xa7, 0x47, 0xdf, 0xcf, + 0xf3, 0xed, 0x42, 0x9d, 0x58, 0x76, 0x61, 0x36, 0xd0, 0xfe, 0x53, 0xe1, 0x28, 0xd5, 0xe9, 0x8f, + 0xf6, 0xdb, 0x10, 0x98, 0x24, 0xd5, 0x1c, 0x2f, 0x33, 0x6c, 0x70, 0x37, 0x67, 0xfb, 0xef, 0x59, + 0x70, 0xbf, 0x4e, 0xa8, 0xc5, 0xaf, 0xf6, 0xb3, 0x27, 0xd7, 0x60, 0x2c, 0x6c, 0x93, 0xc8, 0x49, + 0xcf, 0x64, 0xe7, 0x64, 0xa7, 0x5f, 0x13, 0xf0, 0xc3, 0x83, 0xf9, 0x93, 0x3a, 0x77, 0x09, 0xc7, + 0xaa, 0x24, 0xb2, 0x61, 0x84, 0x75, 0x46, 0x2c, 0x62, 0x8b, 0x59, 0x2e, 0x2d, 0x76, 0xdd, 0x15, + 0x63, 0x81, 0xb1, 0x7f, 0xd6, 0xe2, 0x13, 0x4b, 0x6f, 0x3a, 0x7a, 0x17, 0x66, 0x76, 0xe9, 0xf1, + 0x6d, 0xf5, 0x56, 0x3b, 0xe2, 0x66, 0x74, 0xd9, 0x4f, 0x4f, 0xf6, 0xeb, 0x27, 0xed, 0x23, 0x97, + 0xab, 0xa2, 0xcd, 0x33, 0x57, 0x32, 0xcc, 0x70, 0x17, 0x7b, 0xfb, 0xcf, 0x4b, 0x7c, 0x25, 0x32, + 0xad, 0xee, 0x71, 0x18, 0x6d, 0x87, 0xee, 0x4a, 0xbd, 0x86, 0x45, 0x0f, 0x29, 0x71, 0xd5, 0xe0, + 0x60, 0x2c, 0xf1, 0xe8, 0x3c, 0x00, 0xb9, 0x95, 0x90, 0x28, 0x70, 0x7c, 0x75, 0x19, 0xaf, 0x94, + 0xa7, 0x55, 0x85, 0xc1, 0x1a, 0x15, 0x2d, 0xd3, 0x8e, 0xc2, 0x3d, 0xcf, 0x65, 0xc1, 0x1d, 0x65, + 0xb3, 0x4c, 0x43, 0x61, 0xb0, 0x46, 0x45, 0x8f, 0xca, 0x9d, 0x20, 0xe6, 0x1b, 0xa0, 0xb3, 0x21, + 0xd2, 0xf1, 0x8c, 0xa5, 0x47, 0xe5, 0xeb, 0x3a, 0x12, 0x9b, 0xb4, 0x68, 0x09, 0x46, 0x12, 0x87, + 0x5d, 0x31, 0x0f, 0x17, 0xbb, 0xec, 0xac, 0x53, 0x0a, 0x3d, 0x71, 0x14, 0x2d, 0x80, 0x45, 0x41, + 0xf4, 0xa6, 0x14, 0xc1, 0x5c, 0x24, 0x0b, 0xd7, 0xab, 0xc2, 0x69, 0xab, 0x8b, 0x6f, 0x5d, 0x06, + 0x0b, 0x97, 0x2e, 0x83, 0x97, 0xfd, 0xc5, 0x0a, 0x40, 0xaa, 0xed, 0xa1, 0xf7, 0xba, 0x44, 0xc4, + 0x53, 0xbd, 0xf5, 0xc3, 0xbb, 0x27, 0x1f, 0xd0, 0x97, 0x2c, 0x18, 0x77, 0x7c, 0x3f, 0x6c, 0x39, + 0x09, 0xeb, 0xe5, 0x52, 0x6f, 0x11, 0x25, 0xea, 0x5f, 0x4a, 0x4b, 0xf0, 0x26, 0x3c, 0x2b, 0x6f, + 0x8f, 0x35, 0x4c, 0xdf, 0x56, 0xe8, 0x15, 0xa3, 0x8f, 0xcb, 0x43, 0x00, 0x9f, 0x1e, 0x73, 0xd9, + 0x43, 0x40, 0x85, 0x49, 0x63, 0x4d, 0xff, 0x47, 0xd7, 0x8d, 0xbc, 0x35, 0x43, 0xc5, 0x21, 0xba, + 0x86, 0xd2, 0xd3, 0x2f, 0x65, 0x0d, 0x6a, 0xe8, 0x2e, 0xe8, 0xc3, 0xc5, 0x71, 0xec, 0x9a, 0x76, + 0xdd, 0xc7, 0xfd, 0xfc, 0x1d, 0x98, 0x76, 0xcd, 0xed, 0x56, 0xcc, 0xa6, 0xc7, 0x8a, 0xf8, 0x66, + 0x76, 0xe7, 0x74, 0x83, 0xcd, 0x20, 0x70, 0x96, 0x31, 0x6a, 0xf0, 0x60, 0x80, 0x7a, 0xb0, 0x19, + 0x0a, 0x17, 0x3e, 0xbb, 0x70, 0x2c, 0xf7, 0xe3, 0x84, 0xec, 0x52, 0xca, 0x74, 0x1f, 0xbd, 0x2a, + 0xca, 0x62, 0xc5, 0x05, 0xbd, 0x0a, 0x23, 0x2c, 0x4a, 0x2b, 0xae, 0x8e, 0x15, 0xdb, 0x01, 0xcd, + 0x00, 0xe3, 0x74, 0x51, 0xb1, 0xbf, 0x31, 0x16, 0x1c, 0xd0, 0x45, 0x99, 0x26, 0x20, 0xae, 0x07, + 0xd7, 0x63, 0xc2, 0xd2, 0x04, 0x54, 0x96, 0x3f, 0x9a, 0x66, 0x00, 0xe0, 0xf0, 0xdc, 0x14, 0x91, + 0x46, 0x49, 0xaa, 0xaf, 0x88, 0xff, 0x32, 0xf3, 0x64, 0x15, 0x8a, 0x9b, 0x67, 0x66, 0xa7, 0x4c, + 0xbb, 0xf3, 0x86, 0xc9, 0x02, 0x67, 0x79, 0x1e, 0xeb, 0xf6, 0x39, 0x17, 0xc0, 0x4c, 0x76, 0x61, + 0xdd, 0xd3, 0xed, 0xfa, 0x07, 0x43, 0x30, 0x65, 0x4e, 0x04, 0xb4, 0x08, 0x15, 0xc1, 0x44, 0xa5, + 0x0c, 0x53, 0x73, 0xfb, 0x8a, 0x44, 0xe0, 0x94, 0x86, 0xa5, 0x4c, 0x63, 0xc5, 0x35, 0xdf, 0xac, + 0x34, 0x65, 0x9a, 0xc2, 0x60, 0x8d, 0x8a, 0x2a, 0xd1, 0x1b, 0x61, 0x98, 0xa8, 0xad, 0x40, 0xcd, + 0x96, 0x65, 0x06, 0xc5, 0x02, 0x4b, 0xb7, 0x80, 0x1d, 0x12, 0x05, 0xc4, 0x37, 0x2d, 0x99, 0x6a, + 0x0b, 0xb8, 0xa4, 0x23, 0xb1, 0x49, 0x4b, 0xb7, 0xb4, 0x30, 0x66, 0xd3, 0x4f, 0xa8, 0xea, 0xa9, + 0xaf, 0x5b, 0x93, 0x47, 0x29, 0x4a, 0x3c, 0x7a, 0x03, 0xee, 0x57, 0x41, 0x85, 0x98, 0x5b, 0x86, + 0x65, 0x8d, 0x23, 0xc6, 0xc9, 0xfa, 0xfe, 0x95, 0x7c, 0x32, 0x5c, 0x54, 0x1e, 0xbd, 0x02, 0x53, + 0x42, 0x05, 0x96, 0x1c, 0x47, 0x4d, 0x67, 0x85, 0x4b, 0x06, 0x16, 0x67, 0xa8, 0x51, 0x0d, 0x66, + 0x28, 0x84, 0x69, 0xa1, 0x92, 0x03, 0x0f, 0x8e, 0x54, 0x7b, 0xfd, 0xa5, 0x0c, 0x1e, 0x77, 0x95, + 0x40, 0x4b, 0x30, 0xcd, 0x75, 0x14, 0x7a, 0xa6, 0x64, 0xe3, 0x20, 0x3c, 0x6b, 0xd5, 0x42, 0xb8, + 0x66, 0xa2, 0x71, 0x96, 0x1e, 0xbd, 0x08, 0x13, 0x4e, 0xd4, 0xda, 0xf6, 0x12, 0xd2, 0x4a, 0x3a, + 0x11, 0x4f, 0xc2, 0xa1, 0x79, 0x7b, 0x2c, 0x69, 0x38, 0x6c, 0x50, 0xda, 0xef, 0xc1, 0x89, 0x1c, + 0xa7, 0x7c, 0x3a, 0x71, 0x9c, 0xb6, 0x27, 0xbf, 0x29, 0xe3, 0xb5, 0xb6, 0xd4, 0xa8, 0xcb, 0xaf, + 0xd1, 0xa8, 0xe8, 0xec, 0x64, 0x26, 0x71, 0x2d, 0x3d, 0xac, 0x9a, 0x9d, 0x6b, 0x12, 0x81, 0x53, + 0x1a, 0xfb, 0xdb, 0x00, 0x9a, 0x41, 0x67, 0x00, 0x9f, 0xa5, 0x17, 0x61, 0x42, 0xe6, 0x34, 0xd6, + 0x72, 0x69, 0xaa, 0xcf, 0xbc, 0xa0, 0xe1, 0xb0, 0x41, 0x49, 0xdb, 0x16, 0xa8, 0x4c, 0xa0, 0x19, + 0x1f, 0xb9, 0x34, 0x0f, 0x68, 0x4a, 0x83, 0x9e, 0x82, 0xb1, 0x98, 0xf8, 0x9b, 0x97, 0xbd, 0x60, + 0x47, 0x4c, 0x6c, 0x25, 0x85, 0x9b, 0x02, 0x8e, 0x15, 0x05, 0x5a, 0x86, 0x72, 0xc7, 0x73, 0xc5, + 0x54, 0x96, 0x1b, 0x7e, 0xf9, 0x7a, 0xbd, 0x76, 0x78, 0x30, 0xff, 0x70, 0x51, 0xaa, 0x66, 0x7a, + 0xb4, 0x8f, 0x17, 0xe8, 0xf2, 0xa3, 0x85, 0xf3, 0xee, 0x06, 0x46, 0x8e, 0x78, 0x37, 0x70, 0x1e, + 0x40, 0x7c, 0xb5, 0x9c, 0xcb, 0xe5, 0x74, 0xd4, 0x2e, 0x28, 0x0c, 0xd6, 0xa8, 0x50, 0x0c, 0xb3, + 0xad, 0x88, 0x38, 0xf2, 0x0c, 0xcd, 0xdd, 0xcb, 0xc7, 0xee, 0xdc, 0x40, 0xb0, 0x92, 0x65, 0x86, + 0xbb, 0xf9, 0xa3, 0x10, 0x66, 0x5d, 0x11, 0xc3, 0x9a, 0x56, 0x5a, 0x39, 0xba, 0x4f, 0x3b, 0x73, + 0xc8, 0xc9, 0x32, 0xc2, 0xdd, 0xbc, 0xd1, 0xdb, 0x30, 0x27, 0x81, 0xdd, 0x61, 0xc3, 0x6c, 0xb9, + 0x94, 0x97, 0xcf, 0xdc, 0x3e, 0x98, 0x9f, 0xab, 0x15, 0x52, 0xe1, 0x1e, 0x1c, 0x10, 0x86, 0x11, + 0x76, 0x97, 0x14, 0x57, 0xc7, 0xd9, 0x3e, 0xf7, 0x44, 0xb1, 0x31, 0x80, 0xce, 0xf5, 0x05, 0x76, + 0x0f, 0x25, 0xdc, 0x7c, 0xd3, 0x6b, 0x39, 0x06, 0xc4, 0x82, 0x13, 0xda, 0x84, 0x71, 0x27, 0x08, + 0xc2, 0xc4, 0xe1, 0x2a, 0xd4, 0x44, 0xb1, 0xee, 0xa7, 0x31, 0x5e, 0x4a, 0x4b, 0x70, 0xee, 0xca, + 0x73, 0x50, 0xc3, 0x60, 0x9d, 0x31, 0xba, 0x09, 0xd3, 0xe1, 0x4d, 0x2a, 0x1c, 0xa5, 0x95, 0x22, + 0xae, 0x4e, 0xb2, 0xba, 0x9e, 0x1b, 0xd0, 0x4e, 0x6b, 0x14, 0xd6, 0xa4, 0x96, 0xc9, 0x14, 0x67, + 0x6b, 0x41, 0x0b, 0x86, 0xb5, 0x7a, 0x2a, 0xf5, 0x67, 0x4f, 0xad, 0xd5, 0xba, 0x71, 0x9a, 0x85, + 0xa1, 0x73, 0xb7, 0x55, 0xb6, 0xfa, 0xa7, 0x33, 0x61, 0xe8, 0x29, 0x0a, 0xeb, 0x74, 0x68, 0x1b, + 0x26, 0xd2, 0x2b, 0xab, 0x28, 0x66, 0x59, 0x6a, 0xc6, 0xcf, 0x9f, 0x1f, 0xec, 0xe3, 0xea, 0x5a, + 0x49, 0x7e, 0x72, 0xd0, 0x21, 0xd8, 0xe0, 0x3c, 0xf7, 0x13, 0x30, 0xae, 0x0d, 0xec, 0x51, 0xbc, + 0xb2, 0xe7, 0x5e, 0x81, 0x99, 0xec, 0xd0, 0x1d, 0xc9, 0xab, 0xfb, 0x7f, 0x95, 0x60, 0x3a, 0xe7, + 0xe6, 0x8a, 0xa5, 0x7b, 0xce, 0x08, 0xd4, 0x34, 0xbb, 0xb3, 0x29, 0x16, 0x4b, 0x03, 0x88, 0x45, + 0x29, 0xa3, 0xcb, 0x85, 0x32, 0x5a, 0x88, 0xc2, 0xa1, 0xf7, 0x23, 0x0a, 0xcd, 0xdd, 0x67, 0x78, + 0xa0, 0xdd, 0xe7, 0x2e, 0x88, 0x4f, 0x63, 0x03, 0x1b, 0x1d, 0x60, 0x03, 0xfb, 0x85, 0x12, 0xcc, + 0x64, 0x73, 0x0a, 0x1f, 0xc3, 0x7d, 0xc7, 0xab, 0xc6, 0x7d, 0x47, 0x7e, 0xf2, 0xf4, 0x6c, 0xa6, + 0xe3, 0xa2, 0xbb, 0x0f, 0x9c, 0xb9, 0xfb, 0x78, 0x62, 0x20, 0x6e, 0xbd, 0xef, 0x41, 0xfe, 0x7e, + 0x09, 0x4e, 0x65, 0x8b, 0xac, 0xf8, 0x8e, 0xb7, 0x7b, 0x0c, 0x7d, 0x73, 0xcd, 0xe8, 0x9b, 0xa7, + 0x07, 0xf9, 0x1a, 0xd6, 0xb4, 0xc2, 0x0e, 0x7a, 0x3d, 0xd3, 0x41, 0x8b, 0x83, 0xb3, 0xec, 0xdd, + 0x4b, 0xdf, 0xb6, 0xe0, 0x74, 0x6e, 0xb9, 0x63, 0xb0, 0xbe, 0x5e, 0x35, 0xad, 0xaf, 0x8f, 0x0f, + 0xfc, 0x4d, 0x05, 0xe6, 0xd8, 0xaf, 0x96, 0x0b, 0xbe, 0x85, 0xd9, 0xaf, 0xae, 0xc1, 0xb8, 0xd3, + 0x6a, 0x91, 0x38, 0xbe, 0x12, 0xba, 0x2a, 0xad, 0xd5, 0xd3, 0x6c, 0x4f, 0x4a, 0xc1, 0x87, 0x07, + 0xf3, 0x73, 0x59, 0x16, 0x29, 0x1a, 0xeb, 0x1c, 0xcc, 0x54, 0x79, 0xa5, 0xbb, 0x9a, 0x2a, 0xef, + 0x3c, 0xc0, 0x9e, 0x3a, 0xd5, 0x66, 0x8d, 0x61, 0xda, 0x79, 0x57, 0xa3, 0x42, 0x3f, 0xc5, 0x74, + 0x45, 0xee, 0x32, 0xc2, 0x2f, 0x39, 0x9e, 0x1d, 0x70, 0xac, 0x74, 0xf7, 0x13, 0x1e, 0x08, 0xab, + 0x0c, 0x87, 0x8a, 0x25, 0xfa, 0x0c, 0xcc, 0xc4, 0x3c, 0xd7, 0xc2, 0x8a, 0xef, 0xc4, 0x2c, 0xfc, + 0x42, 0xc8, 0x44, 0x16, 0xdd, 0xda, 0xcc, 0xe0, 0x70, 0x17, 0xb5, 0xfd, 0x8f, 0xcb, 0xf0, 0x40, + 0x8f, 0x29, 0x8a, 0x96, 0xcc, 0x2b, 0xde, 0x27, 0xb3, 0xd6, 0x9d, 0xb9, 0xdc, 0xc2, 0x86, 0xb9, + 0x27, 0x33, 0xc6, 0xa5, 0xf7, 0x3d, 0xc6, 0x5f, 0xb6, 0x34, 0xbb, 0x1b, 0x77, 0x04, 0xfd, 0xd4, + 0x11, 0x97, 0xde, 0x8f, 0xaa, 0xa1, 0xfe, 0x0b, 0x16, 0x3c, 0x9c, 0xfb, 0x59, 0x86, 0xab, 0xc8, + 0x22, 0x54, 0x5a, 0x14, 0xa8, 0x85, 0x48, 0xa5, 0x81, 0x8a, 0x12, 0x81, 0x53, 0x1a, 0xc3, 0x23, + 0xa4, 0xd4, 0xd7, 0x23, 0xe4, 0x5f, 0x5a, 0x70, 0x32, 0xdb, 0x88, 0x63, 0x90, 0x4c, 0x75, 0x53, + 0x32, 0x7d, 0x74, 0x90, 0x21, 0x2f, 0x10, 0x4a, 0x7f, 0x3a, 0x05, 0xf7, 0x15, 0x64, 0xfc, 0xdf, + 0x83, 0xd9, 0xad, 0x16, 0x31, 0x83, 0xcf, 0xc4, 0xc7, 0xe4, 0xc6, 0xe9, 0xf5, 0x8c, 0x54, 0xe3, + 0xc7, 0x90, 0x2e, 0x12, 0xdc, 0x5d, 0x05, 0xfa, 0x82, 0x05, 0x27, 0x9d, 0x9b, 0x71, 0xd7, 0x0b, + 0x3c, 0x62, 0xce, 0x3c, 0x97, 0x6b, 0x1d, 0xeb, 0xf3, 0x62, 0x0f, 0x0b, 0x10, 0x39, 0x99, 0x47, + 0x85, 0x73, 0xeb, 0x42, 0x58, 0x64, 0xf6, 0xa3, 0x5a, 0x4e, 0x8f, 0xf0, 0xc8, 0xbc, 0xe0, 0x15, + 0x2e, 0xa3, 0x24, 0x06, 0x2b, 0x3e, 0xe8, 0x06, 0x54, 0xb6, 0x64, 0x44, 0x99, 0x90, 0x81, 0xb9, + 0x9b, 0x4a, 0x6e, 0xd8, 0x19, 0xf7, 0xd8, 0x57, 0x28, 0x9c, 0xb2, 0x42, 0xaf, 0x40, 0x39, 0xd8, + 0x8c, 0x7b, 0x3d, 0x79, 0x90, 0xf1, 0xa0, 0xe2, 0x71, 0xae, 0x57, 0xd7, 0x9a, 0x98, 0x16, 0xa4, + 0xe5, 0xa3, 0x0d, 0x57, 0x18, 0x74, 0x73, 0xcb, 0xe3, 0xe5, 0x5a, 0x77, 0x79, 0xbc, 0x5c, 0xc3, + 0xb4, 0x20, 0x5a, 0x83, 0x61, 0x16, 0xa0, 0x22, 0xac, 0xb5, 0xb9, 0x71, 0xfa, 0x5d, 0xc1, 0x37, + 0x3c, 0xf0, 0x95, 0x81, 0x31, 0x2f, 0x8e, 0x5e, 0x85, 0x91, 0x16, 0x7b, 0x01, 0x40, 0x1c, 0xad, + 0xf3, 0x73, 0x4f, 0x74, 0xbd, 0x11, 0xc0, 0xef, 0xa8, 0x38, 0x1c, 0x0b, 0x0e, 0x68, 0x1d, 0x46, + 0x5a, 0xa4, 0xbd, 0xbd, 0x19, 0x8b, 0x13, 0xf3, 0xc7, 0x73, 0x79, 0xf5, 0x78, 0xf0, 0x42, 0x70, + 0x65, 0x14, 0x58, 0xf0, 0x42, 0x9f, 0x84, 0xd2, 0x66, 0x4b, 0xc4, 0xaa, 0xe4, 0x5a, 0x69, 0xcd, + 0x60, 0xe4, 0xe5, 0x91, 0xdb, 0x07, 0xf3, 0xa5, 0xb5, 0x15, 0x5c, 0xda, 0x6c, 0xa1, 0xab, 0x30, + 0xba, 0xc9, 0x23, 0x4a, 0x45, 0xa6, 0xd6, 0xc7, 0xf2, 0x83, 0x5d, 0xbb, 0x82, 0x4e, 0x79, 0x8c, + 0x85, 0x40, 0x60, 0xc9, 0x04, 0xad, 0x03, 0x6c, 0xaa, 0xc8, 0x58, 0x91, 0xaa, 0xf5, 0xa3, 0x83, + 0xc4, 0xcf, 0x8a, 0xe3, 0xa3, 0x82, 0x62, 0x8d, 0x0f, 0xfa, 0x1c, 0x54, 0x1c, 0xf9, 0xa6, 0x0b, + 0x4b, 0xd3, 0x6a, 0xee, 0xd3, 0xe9, 0x82, 0xeb, 0xfd, 0xdc, 0x0d, 0x9f, 0xad, 0x8a, 0x08, 0xa7, + 0x4c, 0xd1, 0x0e, 0x4c, 0xee, 0xc5, 0xed, 0x6d, 0x22, 0x17, 0x28, 0xcb, 0xdd, 0x6a, 0x1e, 0x35, + 0xd3, 0x44, 0xbb, 0x82, 0xd0, 0x8b, 0x92, 0x8e, 0xe3, 0x77, 0xc9, 0x14, 0x16, 0x90, 0x73, 0x43, + 0x67, 0x86, 0x4d, 0xde, 0xb4, 0xd3, 0xdf, 0xed, 0x84, 0x1b, 0xfb, 0x09, 0x11, 0x19, 0x5d, 0x73, + 0x3b, 0xfd, 0x35, 0x4e, 0xd2, 0xdd, 0xe9, 0x02, 0x81, 0x25, 0x13, 0xba, 0x84, 0x1d, 0xf9, 0x5e, + 0x92, 0x38, 0x23, 0x3f, 0x5e, 0xd8, 0x3d, 0x5d, 0xed, 0x4d, 0x3b, 0x85, 0xc9, 0xbe, 0x94, 0x15, + 0x93, 0x79, 0xed, 0xed, 0x30, 0x09, 0x83, 0x8c, 0xbc, 0x9d, 0x2d, 0x96, 0x79, 0x8d, 0x1c, 0xfa, + 0x6e, 0x99, 0x97, 0x47, 0x85, 0x73, 0xeb, 0x42, 0x2e, 0x4c, 0xb5, 0xc3, 0x28, 0xb9, 0x19, 0x46, + 0x72, 0x56, 0xa1, 0x1e, 0x87, 0x27, 0x83, 0x52, 0xd4, 0xc8, 0xfc, 0x6b, 0x4d, 0x0c, 0xce, 0xf0, + 0xa4, 0x43, 0x12, 0xb7, 0x1c, 0x9f, 0xd4, 0xaf, 0x55, 0x4f, 0x14, 0x0f, 0x49, 0x93, 0x93, 0x74, + 0x0f, 0x89, 0x40, 0x60, 0xc9, 0x84, 0x4a, 0x1f, 0x96, 0x1c, 0x9c, 0xa5, 0xa0, 0x2d, 0x90, 0x3e, + 0x5d, 0x9e, 0xa7, 0x5c, 0xfa, 0x30, 0x30, 0xe6, 0xc5, 0xe9, 0xcc, 0x17, 0x3a, 0x61, 0x18, 0x57, + 0x4f, 0x15, 0xcf, 0x7c, 0xa1, 0x4a, 0x5e, 0x6b, 0xf6, 0x9a, 0xf9, 0x8a, 0x08, 0xa7, 0x4c, 0xed, + 0x6f, 0x8c, 0x74, 0x6b, 0x0b, 0x4c, 0xf7, 0xff, 0xa2, 0xd5, 0x75, 0x7d, 0xfa, 0x89, 0x41, 0x0f, + 0xac, 0x77, 0xf1, 0x22, 0xf5, 0x0b, 0x16, 0xdc, 0xd7, 0xce, 0xfd, 0x28, 0xb1, 0xf5, 0x0e, 0x76, + 0xee, 0xe5, 0xdd, 0xa0, 0x92, 0x3b, 0xe7, 0xe3, 0x71, 0x41, 0x4d, 0x59, 0x1d, 0xb9, 0xfc, 0xbe, + 0x75, 0xe4, 0x2b, 0x30, 0xc6, 0xd4, 0xbb, 0x34, 0x91, 0xcc, 0x40, 0x4e, 0x48, 0x6c, 0x13, 0x5f, + 0x11, 0x05, 0xb1, 0x62, 0x81, 0x7e, 0xce, 0x82, 0x87, 0xb2, 0x4d, 0xc7, 0x84, 0xa1, 0x45, 0x62, + 0x42, 0x7e, 0xec, 0x58, 0x13, 0xdf, 0xff, 0x50, 0xa3, 0x17, 0xf1, 0x61, 0x3f, 0x02, 0xdc, 0xbb, + 0x32, 0x54, 0xcb, 0x39, 0xf7, 0x8c, 0x98, 0xb7, 0x2b, 0xfd, 0xcf, 0x3e, 0xe8, 0x39, 0x98, 0xd8, + 0x0d, 0x3b, 0x81, 0x8c, 0x10, 0x10, 0xf1, 0x9f, 0xcc, 0x92, 0x77, 0x45, 0x83, 0x63, 0x83, 0xea, + 0x78, 0xf5, 0xfd, 0xaf, 0x59, 0x39, 0x8a, 0x2a, 0x3f, 0x99, 0xbd, 0x6c, 0x9e, 0xcc, 0x1e, 0xcd, + 0x9e, 0xcc, 0xba, 0xec, 0x2c, 0xc6, 0xa1, 0x6c, 0xf0, 0x84, 0xab, 0x83, 0x66, 0xda, 0xb1, 0x7d, + 0x38, 0xdb, 0x4f, 0x38, 0x33, 0x47, 0x2c, 0x57, 0xdd, 0x50, 0xa6, 0x8e, 0x58, 0x6e, 0xbd, 0x86, + 0x19, 0x66, 0xd0, 0x9c, 0x0d, 0xf6, 0x7f, 0xb3, 0xa0, 0xdc, 0x08, 0xdd, 0x63, 0xb0, 0x1b, 0x7d, + 0xca, 0xb0, 0x1b, 0x3d, 0x50, 0xf0, 0xfa, 0x62, 0xa1, 0x95, 0x68, 0x35, 0x63, 0x25, 0x7a, 0xa8, + 0x88, 0x41, 0x6f, 0x9b, 0xd0, 0x3f, 0x28, 0x83, 0xfe, 0x56, 0x24, 0xfa, 0xd7, 0x77, 0xe2, 0xd1, + 0x5b, 0xee, 0xf5, 0x7c, 0xa4, 0xe0, 0xcc, 0xfc, 0xb7, 0x64, 0xb0, 0xe0, 0x8f, 0x98, 0x63, 0xef, + 0xeb, 0xc4, 0xdb, 0xda, 0x4e, 0x88, 0x9b, 0xfd, 0x9c, 0xe3, 0x73, 0xec, 0xfd, 0x2f, 0x16, 0x4c, + 0x67, 0x6a, 0x47, 0x7e, 0x5e, 0xe4, 0xd1, 0x1d, 0x5a, 0x82, 0x66, 0xfb, 0x86, 0x2a, 0x2d, 0x00, + 0x28, 0xa3, 0xbc, 0xb4, 0xb6, 0x30, 0xdd, 0x57, 0x59, 0xed, 0x63, 0xac, 0x51, 0xa0, 0xe7, 0x61, + 0x3c, 0x09, 0xdb, 0xa1, 0x1f, 0x6e, 0xed, 0x5f, 0x22, 0x32, 0x4b, 0x88, 0xba, 0x3a, 0x59, 0x4f, + 0x51, 0x58, 0xa7, 0xb3, 0x7f, 0xb5, 0x0c, 0xd9, 0xf7, 0x45, 0xff, 0xff, 0x9c, 0xfc, 0x70, 0xce, + 0xc9, 0xef, 0x5a, 0x30, 0x43, 0x6b, 0x67, 0xbe, 0x31, 0xd2, 0x25, 0x56, 0xbd, 0xcc, 0x60, 0xf5, + 0x78, 0x99, 0xe1, 0x51, 0x2a, 0xbb, 0xdc, 0xb0, 0x93, 0x08, 0xab, 0x90, 0x26, 0x9c, 0x28, 0x14, + 0x0b, 0xac, 0xa0, 0x23, 0x51, 0x24, 0xe2, 0x89, 0x74, 0x3a, 0x12, 0x45, 0x58, 0x60, 0xe5, 0xc3, + 0x0d, 0x43, 0x05, 0x0f, 0x37, 0xb0, 0x04, 0x5b, 0xc2, 0x1f, 0x43, 0x28, 0x14, 0x5a, 0x82, 0x2d, + 0xe9, 0xa8, 0x91, 0xd2, 0xd8, 0x5f, 0x2f, 0xc3, 0x44, 0x23, 0x74, 0x53, 0x2f, 0xfa, 0xe7, 0x0c, + 0x2f, 0xfa, 0xb3, 0x19, 0x2f, 0xfa, 0x19, 0x9d, 0xf6, 0xee, 0x38, 0xd1, 0x8b, 0xf4, 0x6b, 0xec, + 0x19, 0x91, 0x3b, 0x74, 0xa0, 0x37, 0xd2, 0xaf, 0x29, 0x46, 0xd8, 0xe4, 0xfb, 0xe3, 0xe4, 0x38, + 0xff, 0x17, 0x16, 0x4c, 0x35, 0x42, 0x97, 0x4e, 0xd0, 0x1f, 0xa7, 0xd9, 0xa8, 0xa7, 0x6f, 0x1b, + 0xe9, 0x91, 0xbe, 0xed, 0x1f, 0x5a, 0x30, 0xda, 0x08, 0xdd, 0x63, 0xb0, 0x98, 0xbe, 0x6c, 0x5a, + 0x4c, 0xef, 0x2f, 0x90, 0xb2, 0x05, 0x46, 0xd2, 0xdf, 0x2a, 0xc3, 0x24, 0x6d, 0x67, 0xb8, 0x25, + 0x47, 0xc9, 0xe8, 0x11, 0x6b, 0x80, 0x1e, 0xa1, 0xca, 0x5c, 0xe8, 0xfb, 0xe1, 0xcd, 0xec, 0x88, + 0xad, 0x31, 0x28, 0x16, 0x58, 0xf4, 0x14, 0x8c, 0xb5, 0x23, 0xb2, 0xe7, 0x85, 0x9d, 0x38, 0x1b, + 0x91, 0xd8, 0x10, 0x70, 0xac, 0x28, 0xa8, 0xde, 0x1e, 0x7b, 0x41, 0x8b, 0x48, 0x1f, 0x8d, 0x21, + 0xe6, 0xa3, 0xc1, 0x33, 0x60, 0x6a, 0x70, 0x6c, 0x50, 0xa1, 0xd7, 0xa1, 0xc2, 0xfe, 0xb3, 0x75, + 0x73, 0xf4, 0x77, 0x19, 0xf8, 0x01, 0x57, 0x32, 0xc0, 0x29, 0x2f, 0x74, 0x1e, 0x20, 0x91, 0xde, + 0x24, 0xb1, 0x08, 0x98, 0x55, 0x1a, 0xa5, 0xf2, 0x33, 0x89, 0xb1, 0x46, 0x85, 0x9e, 0x84, 0x4a, + 0xe2, 0x78, 0xfe, 0x65, 0x2f, 0x20, 0xb1, 0xf0, 0xc6, 0x11, 0x59, 0xa5, 0x05, 0x10, 0xa7, 0x78, + 0xba, 0xa3, 0xb3, 0x70, 0x6c, 0xfe, 0xaa, 0xcb, 0x18, 0xa3, 0x66, 0x3b, 0xfa, 0x65, 0x05, 0xc5, + 0x1a, 0x85, 0xfd, 0x22, 0x9c, 0x6a, 0x84, 0x6e, 0x23, 0x8c, 0x92, 0xb5, 0x30, 0xba, 0xe9, 0x44, + 0xae, 0x1c, 0xbf, 0x79, 0x99, 0xe0, 0x98, 0xee, 0xba, 0xc3, 0xdc, 0x1a, 0x60, 0xa4, 0x2e, 0x7e, + 0x96, 0xed, 0xe9, 0x47, 0x0c, 0x9d, 0xf8, 0x77, 0x25, 0x40, 0x0d, 0xe6, 0xef, 0x62, 0x3c, 0xfd, + 0xf3, 0x36, 0x4c, 0xc5, 0xe4, 0xb2, 0x17, 0x74, 0x6e, 0xc9, 0xf3, 0x55, 0x8f, 0xb8, 0x94, 0xe6, + 0xaa, 0x4e, 0xc9, 0x2d, 0x2a, 0x26, 0x0c, 0x67, 0xb8, 0xd1, 0x2e, 0x8c, 0x3a, 0xc1, 0x52, 0x7c, + 0x3d, 0x26, 0x91, 0x78, 0xea, 0x86, 0x75, 0x21, 0x96, 0x40, 0x9c, 0xe2, 0xe9, 0x94, 0x61, 0x7f, + 0xae, 0x86, 0x01, 0x0e, 0xc3, 0x44, 0x4e, 0x32, 0xf6, 0x58, 0x82, 0x06, 0xc7, 0x06, 0x15, 0x5a, + 0x03, 0x14, 0x77, 0xda, 0x6d, 0x9f, 0x5d, 0x0f, 0x3a, 0xfe, 0x85, 0x28, 0xec, 0xb4, 0xb9, 0xc3, + 0xb2, 0x78, 0x67, 0xa0, 0xd9, 0x85, 0xc5, 0x39, 0x25, 0xa8, 0x60, 0xd8, 0x8c, 0xd9, 0x6f, 0x11, + 0x91, 0xcd, 0x6d, 0x9b, 0x4d, 0x06, 0xc2, 0x12, 0x67, 0x7f, 0x9e, 0x6d, 0x66, 0xec, 0x85, 0x92, + 0xa4, 0x13, 0x11, 0xb4, 0x0b, 0x93, 0x6d, 0xb6, 0x61, 0x25, 0x51, 0xe8, 0xfb, 0x44, 0xea, 0x8d, + 0x77, 0xe6, 0x7b, 0xc3, 0x5f, 0x2c, 0xd0, 0xd9, 0x61, 0x93, 0xbb, 0xfd, 0xc5, 0x69, 0x26, 0x97, + 0x9a, 0xfc, 0xd0, 0x32, 0x2a, 0x3c, 0x6a, 0x85, 0x86, 0x36, 0x57, 0xfc, 0x22, 0x58, 0x2a, 0xe9, + 0x85, 0x57, 0x2e, 0x96, 0x65, 0xd1, 0x6b, 0xcc, 0xd3, 0x9b, 0x0b, 0x83, 0x7e, 0x6f, 0x11, 0x72, + 0x2a, 0xc3, 0xcb, 0x5b, 0x14, 0xc4, 0x1a, 0x13, 0x74, 0x19, 0x26, 0xc5, 0x83, 0x16, 0xc2, 0xf0, + 0x50, 0x36, 0x8e, 0xbf, 0x93, 0x58, 0x47, 0x1e, 0x66, 0x01, 0xd8, 0x2c, 0x8c, 0xb6, 0xe0, 0x21, + 0xed, 0xf9, 0xa5, 0x1c, 0xff, 0x2f, 0x2e, 0x5b, 0x1e, 0xbe, 0x7d, 0x30, 0xff, 0xd0, 0x7a, 0x2f, + 0x42, 0xdc, 0x9b, 0x0f, 0xba, 0x06, 0xa7, 0x9c, 0x56, 0xe2, 0xed, 0x91, 0x1a, 0x71, 0x5c, 0xdf, + 0x0b, 0x88, 0x19, 0xa2, 0x7f, 0xfa, 0xf6, 0xc1, 0xfc, 0xa9, 0xa5, 0x3c, 0x02, 0x9c, 0x5f, 0x0e, + 0xbd, 0x0c, 0x15, 0x37, 0x88, 0x45, 0x1f, 0x8c, 0x18, 0x2f, 0x8b, 0x55, 0x6a, 0x57, 0x9b, 0xea, + 0xfb, 0xd3, 0x3f, 0x38, 0x2d, 0x80, 0xb6, 0x60, 0x42, 0x0f, 0xc3, 0x11, 0xaf, 0xd2, 0x3d, 0xdd, + 0xe3, 0x6c, 0x6b, 0xc4, 0xae, 0x70, 0xab, 0x9b, 0xf2, 0xae, 0x34, 0xc2, 0x5a, 0x0c, 0xc6, 0xe8, + 0x55, 0x40, 0x31, 0x89, 0xf6, 0xbc, 0x16, 0x59, 0x6a, 0xb1, 0x14, 0xb1, 0xcc, 0x56, 0x33, 0x66, + 0x84, 0x0a, 0xa0, 0x66, 0x17, 0x05, 0xce, 0x29, 0x85, 0x2e, 0x52, 0x89, 0xa2, 0x43, 0x85, 0x33, + 0xac, 0x54, 0xf3, 0xaa, 0x35, 0xd2, 0x8e, 0x48, 0xcb, 0x49, 0x88, 0x6b, 0x72, 0xc4, 0x99, 0x72, + 0x74, 0xbf, 0x51, 0x99, 0xf7, 0xc1, 0x74, 0xe1, 0xec, 0xce, 0xbe, 0x4f, 0x4f, 0x48, 0xdb, 0x61, + 0x9c, 0x5c, 0x25, 0xc9, 0xcd, 0x30, 0xda, 0x11, 0x79, 0xb5, 0xd2, 0xb4, 0x7b, 0x29, 0x0a, 0xeb, + 0x74, 0x54, 0x23, 0x62, 0x97, 0x60, 0xf5, 0x1a, 0xbb, 0xa7, 0x18, 0x4b, 0xd7, 0xc9, 0x45, 0x0e, + 0xc6, 0x12, 0x2f, 0x49, 0xeb, 0x8d, 0x15, 0x76, 0xfb, 0x90, 0x21, 0xad, 0x37, 0x56, 0xb0, 0xc4, + 0x23, 0xd2, 0xfd, 0x6a, 0xdb, 0x54, 0xf1, 0xbd, 0x51, 0xb7, 0x5c, 0x1e, 0xf0, 0xe1, 0xb6, 0x00, + 0x66, 0xd4, 0x7b, 0x71, 0x3c, 0xe1, 0x58, 0x5c, 0x9d, 0x66, 0x93, 0x64, 0xf0, 0x6c, 0x65, 0xca, + 0x16, 0x57, 0xcf, 0x70, 0xc2, 0x5d, 0xbc, 0x8d, 0xd4, 0x0f, 0x33, 0x7d, 0x5f, 0x4e, 0x58, 0x84, + 0x4a, 0xdc, 0xd9, 0x70, 0xc3, 0x5d, 0xc7, 0x0b, 0xd8, 0x65, 0x81, 0xfe, 0x6c, 0xbe, 0x44, 0xe0, + 0x94, 0x06, 0xad, 0xc1, 0x98, 0x23, 0x0e, 0x5f, 0xc2, 0xbc, 0x9f, 0x1b, 0x0b, 0x2e, 0x0f, 0x68, + 0xdc, 0x0e, 0x2a, 0xff, 0x61, 0x55, 0x16, 0xbd, 0x04, 0x93, 0x22, 0x5c, 0x49, 0x78, 0x1a, 0x9e, + 0x30, 0x3d, 0xdb, 0x9b, 0x3a, 0x12, 0x9b, 0xb4, 0xe8, 0xa7, 0x60, 0x8a, 0x72, 0x49, 0x05, 0x5b, + 0xf5, 0xe4, 0x20, 0x12, 0x51, 0xcb, 0x88, 0xad, 0x17, 0xc6, 0x19, 0x66, 0xc8, 0x85, 0x07, 0x9d, + 0x4e, 0x12, 0x32, 0x63, 0xa5, 0x39, 0xff, 0xd7, 0xc3, 0x1d, 0x12, 0x30, 0xeb, 0xfe, 0xd8, 0xf2, + 0xd9, 0xdb, 0x07, 0xf3, 0x0f, 0x2e, 0xf5, 0xa0, 0xc3, 0x3d, 0xb9, 0xa0, 0xeb, 0x30, 0x9e, 0x84, + 0xbe, 0x70, 0x11, 0x8e, 0xab, 0xf7, 0x15, 0xa7, 0xae, 0x59, 0x57, 0x64, 0xba, 0x39, 0x41, 0x15, + 0xc5, 0x3a, 0x1f, 0xb4, 0xce, 0xd7, 0x18, 0x4b, 0xb4, 0x48, 0xe2, 0xea, 0xfd, 0xc5, 0x1d, 0xa3, + 0xf2, 0x31, 0x9a, 0x4b, 0x50, 0x94, 0xc4, 0x3a, 0x1b, 0x74, 0x01, 0x66, 0xdb, 0x91, 0x17, 0xb2, + 0x89, 0xad, 0x0c, 0xc5, 0x55, 0x23, 0xa9, 0xd9, 0x6c, 0x23, 0x4b, 0x80, 0xbb, 0xcb, 0xa0, 0x73, + 0x54, 0x41, 0xe5, 0xc0, 0xea, 0x69, 0xfe, 0xa2, 0x06, 0x57, 0x4e, 0x39, 0x0c, 0x2b, 0xec, 0xdc, + 0xa7, 0x61, 0xb6, 0x4b, 0x52, 0x1e, 0xc9, 0x5d, 0xf3, 0xd7, 0x87, 0xa1, 0xa2, 0xcc, 0x81, 0x68, + 0xd1, 0xb4, 0xf2, 0x9e, 0xce, 0x5a, 0x79, 0xc7, 0xa8, 0xbe, 0xa6, 0x1b, 0x76, 0xd7, 0x73, 0x1e, + 0x05, 0x3f, 0x5b, 0x20, 0x1a, 0x06, 0x8f, 0xad, 0x3a, 0xc2, 0x83, 0xe9, 0xe9, 0x81, 0x71, 0xa8, + 0xe7, 0x81, 0x71, 0xc0, 0x07, 0xfa, 0xe8, 0xd1, 0xb0, 0x1d, 0xba, 0xf5, 0x46, 0xf6, 0xc5, 0xaa, + 0x06, 0x05, 0x62, 0x8e, 0x63, 0xca, 0x3d, 0xdd, 0xd6, 0x99, 0x72, 0x3f, 0x7a, 0x87, 0xca, 0xbd, + 0x64, 0x80, 0x53, 0x5e, 0xc8, 0x87, 0xd9, 0x96, 0xf9, 0xd8, 0x98, 0x8a, 0xa7, 0x7a, 0xa4, 0xef, + 0xb3, 0x5f, 0x1d, 0xed, 0x05, 0x92, 0x95, 0x2c, 0x17, 0xdc, 0xcd, 0x18, 0xbd, 0x04, 0x63, 0xef, + 0x86, 0x31, 0x9b, 0x76, 0x62, 0x6f, 0x93, 0x11, 0x2c, 0x63, 0xaf, 0x5d, 0x6b, 0x32, 0xf8, 0xe1, + 0xc1, 0xfc, 0x78, 0x23, 0x74, 0xe5, 0x5f, 0xac, 0x0a, 0xa0, 0x5b, 0x70, 0xca, 0x90, 0x08, 0xaa, + 0xb9, 0x30, 0x78, 0x73, 0x1f, 0x12, 0xd5, 0x9d, 0xaa, 0xe7, 0x71, 0xc2, 0xf9, 0x15, 0xd8, 0xdf, + 0xe0, 0x46, 0x4f, 0x61, 0x1a, 0x21, 0x71, 0xc7, 0x3f, 0x8e, 0x67, 0x06, 0x56, 0x0d, 0xab, 0xcd, + 0x1d, 0x1b, 0xd6, 0xff, 0xc0, 0x62, 0x86, 0xf5, 0x75, 0xb2, 0xdb, 0xf6, 0x9d, 0xe4, 0x38, 0x9c, + 0x74, 0x5f, 0x83, 0xb1, 0x44, 0xd4, 0xd6, 0xeb, 0x65, 0x04, 0xad, 0x51, 0xec, 0x72, 0x41, 0x6d, + 0x88, 0x12, 0x8a, 0x15, 0x1b, 0xfb, 0x9f, 0xf3, 0x11, 0x90, 0x98, 0x63, 0xb0, 0x2d, 0xd4, 0x4c, + 0xdb, 0xc2, 0x7c, 0x9f, 0x2f, 0x28, 0xb0, 0x31, 0xfc, 0x33, 0xb3, 0xdd, 0xec, 0xec, 0xf1, 0x61, + 0xbf, 0xd1, 0xb1, 0x7f, 0xc9, 0x82, 0x93, 0x79, 0x8e, 0x00, 0x54, 0x89, 0xe1, 0x27, 0x1f, 0x75, + 0xc3, 0xa5, 0x7a, 0xf0, 0x86, 0x80, 0x63, 0x45, 0x31, 0x70, 0x76, 0xf2, 0xa3, 0xa5, 0x6b, 0xba, + 0x06, 0xe6, 0xbb, 0x74, 0xe8, 0x15, 0xee, 0x75, 0x6f, 0xa9, 0x87, 0xe3, 0x8e, 0xe6, 0x71, 0x6f, + 0xff, 0x5a, 0x09, 0x4e, 0x72, 0x13, 0xf5, 0xd2, 0x5e, 0xe8, 0xb9, 0x8d, 0xd0, 0x15, 0x31, 0x08, + 0x6f, 0xc2, 0x44, 0x5b, 0x3b, 0xae, 0xf6, 0x4a, 0x18, 0xa3, 0x1f, 0x6b, 0xd3, 0x63, 0x83, 0x0e, + 0xc5, 0x06, 0x2f, 0xe4, 0xc2, 0x04, 0xd9, 0xf3, 0x5a, 0xca, 0xce, 0x59, 0x3a, 0xb2, 0x48, 0x57, + 0xb5, 0xac, 0x6a, 0x7c, 0xb0, 0xc1, 0xf5, 0x1e, 0xbc, 0x21, 0x62, 0x7f, 0xc5, 0x82, 0xfb, 0x0b, + 0xd2, 0xcb, 0xd0, 0xea, 0x6e, 0xb2, 0xcb, 0x00, 0xf1, 0xc8, 0xa1, 0xaa, 0x8e, 0x5f, 0x11, 0x60, + 0x81, 0x45, 0x3f, 0x09, 0xc0, 0x4d, 0xfc, 0xec, 0x49, 0xf9, 0x52, 0xef, 0xf8, 0x75, 0x23, 0xed, + 0x82, 0x16, 0x9b, 0xaf, 0x1e, 0x91, 0xd7, 0x78, 0xd9, 0xbf, 0x52, 0x86, 0x61, 0xfe, 0xe2, 0xf5, + 0x1a, 0x8c, 0x6e, 0xf3, 0x64, 0xb6, 0x83, 0xe4, 0xcd, 0x4d, 0x8f, 0x23, 0x1c, 0x80, 0x65, 0x61, + 0x74, 0x05, 0x4e, 0x88, 0x38, 0x97, 0x1a, 0xf1, 0x9d, 0x7d, 0x79, 0xaa, 0xe5, 0x0f, 0x4b, 0xc8, + 0xa4, 0xe7, 0x27, 0xea, 0xdd, 0x24, 0x38, 0xaf, 0x1c, 0x7a, 0xa5, 0x2b, 0x85, 0x1d, 0x4f, 0x03, + 0xac, 0x74, 0xe0, 0x3e, 0x69, 0xec, 0x5e, 0x82, 0xc9, 0x76, 0xd7, 0xf9, 0x5d, 0x7b, 0x6c, 0xd8, + 0x3c, 0xb3, 0x9b, 0xb4, 0xcc, 0xab, 0xa0, 0xc3, 0x7c, 0x28, 0xd6, 0xb7, 0x23, 0x12, 0x6f, 0x87, + 0xbe, 0x2b, 0x5e, 0xd6, 0x4c, 0xbd, 0x0a, 0x32, 0x78, 0xdc, 0x55, 0x82, 0x72, 0xd9, 0x74, 0x3c, + 0xbf, 0x13, 0x91, 0x94, 0xcb, 0x88, 0xc9, 0x65, 0x2d, 0x83, 0xc7, 0x5d, 0x25, 0xe8, 0x3c, 0x3a, + 0x25, 0x9e, 0x65, 0x94, 0xd1, 0xcf, 0xca, 0x55, 0x64, 0x54, 0xfa, 0xb7, 0xf7, 0xc8, 0xc8, 0x21, + 0xae, 0xfc, 0xd5, 0xc3, 0x8e, 0xda, 0x83, 0x5f, 0xc2, 0xb3, 0x5d, 0x72, 0xb9, 0x93, 0xc7, 0x01, + 0xff, 0xc4, 0x82, 0x13, 0x39, 0xee, 0x63, 0x5c, 0x54, 0x6d, 0x79, 0x71, 0xa2, 0xde, 0x33, 0xd0, + 0x44, 0x15, 0x87, 0x63, 0x45, 0x41, 0xd7, 0x03, 0x17, 0x86, 0x59, 0x01, 0x28, 0x5c, 0x3e, 0x04, + 0xf6, 0x68, 0x02, 0x10, 0x9d, 0x85, 0xa1, 0x4e, 0x4c, 0x22, 0xf9, 0xa2, 0x9e, 0x94, 0xdf, 0xcc, + 0x22, 0xc8, 0x30, 0x54, 0xa3, 0xdc, 0x52, 0xc6, 0x38, 0x4d, 0xa3, 0xe4, 0xe6, 0x38, 0x8e, 0xb3, + 0xbf, 0x5c, 0x86, 0xe9, 0x8c, 0x03, 0x28, 0x6d, 0xc8, 0x6e, 0x18, 0x78, 0x49, 0xa8, 0x32, 0xa8, + 0xf1, 0x84, 0x11, 0xa4, 0xbd, 0x7d, 0x45, 0xc0, 0xb1, 0xa2, 0x40, 0x8f, 0xca, 0xa7, 0x56, 0xb3, + 0xef, 0x34, 0x2c, 0xd7, 0x8c, 0xd7, 0x56, 0x07, 0x7d, 0x70, 0xe5, 0x11, 0x18, 0x6a, 0x87, 0xea, + 0x1d, 0x6c, 0x35, 0x9e, 0x78, 0xb9, 0xd6, 0x08, 0x43, 0x1f, 0x33, 0x24, 0xfa, 0x98, 0xf8, 0xfa, + 0xcc, 0x7d, 0x05, 0x76, 0xdc, 0x30, 0xd6, 0xba, 0xe0, 0x71, 0x18, 0xdd, 0x21, 0xfb, 0x91, 0x17, + 0x6c, 0x65, 0x6f, 0x6b, 0x2e, 0x71, 0x30, 0x96, 0x78, 0x33, 0x61, 0xf9, 0xe8, 0x3d, 0x79, 0x33, + 0x65, 0xac, 0xef, 0xae, 0xf6, 0x5b, 0x16, 0x4c, 0xb3, 0x6c, 0xa5, 0x22, 0xce, 0xde, 0x0b, 0x83, + 0x63, 0xd0, 0x13, 0x1e, 0x81, 0xe1, 0x88, 0x56, 0x9a, 0x7d, 0x08, 0x81, 0xb5, 0x04, 0x73, 0x1c, + 0x7a, 0x10, 0x86, 0x58, 0x13, 0xe8, 0xe0, 0x4d, 0xf0, 0x7c, 0xe5, 0x35, 0x27, 0x71, 0x30, 0x83, + 0xb2, 0x80, 0x27, 0x4c, 0xda, 0xbe, 0xc7, 0x1b, 0x9d, 0x9a, 0x5b, 0x3f, 0x1c, 0x01, 0x4f, 0xb9, + 0x4d, 0x7b, 0x7f, 0x01, 0x4f, 0xf9, 0x2c, 0x7b, 0xeb, 0xe0, 0xff, 0xbd, 0x04, 0x67, 0x72, 0xcb, + 0xa5, 0x37, 0xbb, 0x6b, 0xc6, 0xcd, 0xee, 0xf9, 0xcc, 0xcd, 0xae, 0xdd, 0xbb, 0xf4, 0xdd, 0xb9, + 0xeb, 0xcd, 0xbf, 0x82, 0x2d, 0x1f, 0xe3, 0x15, 0xec, 0xd0, 0xa0, 0x6a, 0xca, 0x70, 0x1f, 0x35, + 0xe5, 0xdb, 0x16, 0x9c, 0xce, 0xed, 0xb2, 0x0f, 0x49, 0x84, 0x59, 0x6e, 0xdb, 0x0a, 0xce, 0x10, + 0x3f, 0x2c, 0x15, 0x7c, 0x0b, 0x3b, 0x4d, 0x9c, 0xa3, 0x72, 0x86, 0x21, 0x63, 0xa1, 0x76, 0x4d, + 0x70, 0x19, 0xc3, 0x61, 0x58, 0x61, 0x91, 0xa7, 0xc5, 0x6a, 0xf1, 0xa6, 0xbd, 0x74, 0xa4, 0x25, + 0xb3, 0x60, 0x5a, 0xc7, 0xf5, 0xa4, 0x00, 0xd9, 0xb8, 0xad, 0x2b, 0xda, 0x09, 0xb0, 0x3c, 0xf8, + 0x09, 0x70, 0x22, 0xff, 0xf4, 0x87, 0x96, 0x60, 0x7a, 0xd7, 0x0b, 0xd8, 0x6b, 0xa6, 0xa6, 0xde, + 0xa3, 0x02, 0x5c, 0xaf, 0x98, 0x68, 0x9c, 0xa5, 0x9f, 0x7b, 0x09, 0x26, 0xef, 0xdc, 0x64, 0xf5, + 0xdd, 0x32, 0x3c, 0xd0, 0x63, 0xd9, 0x73, 0x59, 0x6f, 0x8c, 0x81, 0x26, 0xeb, 0xbb, 0xc6, 0xa1, + 0x01, 0x27, 0x37, 0x3b, 0xbe, 0xbf, 0xcf, 0xbc, 0x9c, 0x88, 0x2b, 0x29, 0x84, 0x62, 0xa2, 0x52, + 0x11, 0xaf, 0xe5, 0xd0, 0xe0, 0xdc, 0x92, 0xe8, 0x55, 0x40, 0xe1, 0x06, 0x4b, 0x8f, 0xeb, 0xa6, + 0xa9, 0x0e, 0x58, 0xc7, 0x97, 0xd3, 0xc5, 0x78, 0xad, 0x8b, 0x02, 0xe7, 0x94, 0xa2, 0x1a, 0x26, + 0x7b, 0x83, 0x5d, 0x35, 0x2b, 0xa3, 0x61, 0x62, 0x1d, 0x89, 0x4d, 0x5a, 0x74, 0x01, 0x66, 0x9d, + 0x3d, 0xc7, 0xe3, 0xa9, 0xaf, 0x24, 0x03, 0xae, 0x62, 0x2a, 0x43, 0xd1, 0x52, 0x96, 0x00, 0x77, + 0x97, 0x41, 0x9b, 0x86, 0x95, 0x8f, 0x67, 0xde, 0x3f, 0x3f, 0xf0, 0x6c, 0x1d, 0xd8, 0xee, 0x67, + 0xff, 0x27, 0x8b, 0x6e, 0x5f, 0x39, 0xcf, 0x67, 0xd2, 0x7e, 0x50, 0xf6, 0x2b, 0x2d, 0xce, 0x4c, + 0xf5, 0xc3, 0x8a, 0x8e, 0xc4, 0x26, 0x2d, 0x9f, 0x10, 0x71, 0xea, 0x64, 0x6d, 0xe8, 0x89, 0x22, + 0x30, 0x53, 0x51, 0xa0, 0x37, 0x60, 0xd4, 0xf5, 0xf6, 0xbc, 0x38, 0x8c, 0xc4, 0x62, 0x39, 0xea, + 0xb3, 0xd1, 0x4a, 0x0e, 0xd6, 0x38, 0x1b, 0x2c, 0xf9, 0xd9, 0x5f, 0x2e, 0xc1, 0xa4, 0xac, 0xf1, + 0xb5, 0x4e, 0x98, 0x38, 0xc7, 0xb0, 0x2d, 0x5f, 0x30, 0xb6, 0xe5, 0x8f, 0xf5, 0x8a, 0x4e, 0x65, + 0x4d, 0x2a, 0xdc, 0x8e, 0xaf, 0x65, 0xb6, 0xe3, 0xc7, 0xfa, 0xb3, 0xea, 0xbd, 0x0d, 0xff, 0xae, + 0x05, 0xb3, 0x06, 0xfd, 0x31, 0xec, 0x06, 0x6b, 0xe6, 0x6e, 0xf0, 0x70, 0xdf, 0x6f, 0x28, 0xd8, + 0x05, 0xbe, 0x56, 0xca, 0xb4, 0x9d, 0x49, 0xff, 0x77, 0x61, 0x68, 0xdb, 0x89, 0xdc, 0x5e, 0x09, + 0x1c, 0xbb, 0x0a, 0x2d, 0x5c, 0x74, 0x22, 0x97, 0xcb, 0xf0, 0xa7, 0xd4, 0xcb, 0x5e, 0x4e, 0xe4, + 0xf6, 0x8d, 0x29, 0x60, 0x55, 0xa1, 0x17, 0x61, 0x24, 0x6e, 0x85, 0x6d, 0xe5, 0x7b, 0x79, 0x96, + 0xbf, 0xfa, 0x45, 0x21, 0x87, 0x07, 0xf3, 0xc8, 0xac, 0x8e, 0x82, 0xb1, 0xa0, 0x9f, 0xdb, 0x82, + 0x8a, 0xaa, 0xfa, 0x9e, 0x7a, 0x95, 0xff, 0x51, 0x19, 0x4e, 0xe4, 0xcc, 0x0b, 0x14, 0x1b, 0xbd, + 0xf5, 0xcc, 0x80, 0xd3, 0xe9, 0x7d, 0xf6, 0x57, 0xcc, 0x4e, 0x2c, 0xae, 0x18, 0xff, 0x81, 0x2b, + 0xbd, 0x1e, 0x93, 0x6c, 0xa5, 0x14, 0xd4, 0xbf, 0x52, 0x5a, 0xd9, 0xb1, 0x75, 0x35, 0xad, 0x48, + 0xb5, 0xf4, 0x9e, 0x8e, 0xe9, 0x9f, 0x95, 0xe1, 0x64, 0x5e, 0x50, 0x3b, 0xfa, 0x99, 0xcc, 0x73, + 0x10, 0xcf, 0x0d, 0x1a, 0x0e, 0xcf, 0xdf, 0x88, 0x10, 0xb9, 0x62, 0x16, 0xcc, 0x07, 0x22, 0xfa, + 0x76, 0xb3, 0xa8, 0x93, 0x05, 0xf9, 0x44, 0xfc, 0x19, 0x0f, 0xb9, 0xc4, 0x3f, 0x31, 0x70, 0x03, + 0xc4, 0xfb, 0x1f, 0x71, 0x26, 0xc8, 0x47, 0x82, 0xfb, 0x07, 0xf9, 0xc8, 0x9a, 0xe7, 0x3c, 0x18, + 0xd7, 0xbe, 0xe6, 0x9e, 0x8e, 0xf8, 0x0e, 0xdd, 0x51, 0xb4, 0x76, 0xdf, 0xd3, 0x51, 0xff, 0x8a, + 0x05, 0x19, 0x3f, 0x29, 0x65, 0xff, 0xb0, 0x0a, 0xed, 0x1f, 0x67, 0x61, 0x28, 0x0a, 0x7d, 0x92, + 0x7d, 0x21, 0x00, 0x87, 0x3e, 0xc1, 0x0c, 0xa3, 0x9e, 0xf1, 0x2d, 0x17, 0x3d, 0xe3, 0x4b, 0x8f, + 0xc6, 0x3e, 0xd9, 0x23, 0xd2, 0x1a, 0xa1, 0x64, 0xf2, 0x65, 0x0a, 0xc4, 0x1c, 0x67, 0xff, 0xc6, + 0x10, 0x9c, 0xc8, 0x09, 0x69, 0xa3, 0x07, 0x95, 0x2d, 0x27, 0x21, 0x37, 0x9d, 0xfd, 0x6c, 0xd6, + 0xd2, 0x0b, 0x1c, 0x8c, 0x25, 0x9e, 0xf9, 0x72, 0xf2, 0xc4, 0x67, 0x19, 0x1b, 0x91, 0xc8, 0x77, + 0x26, 0xb0, 0xf7, 0xea, 0x65, 0xd7, 0xf3, 0x00, 0x71, 0xec, 0xaf, 0x06, 0x54, 0xf9, 0x72, 0x85, + 0xa7, 0x68, 0x9a, 0x25, 0xaf, 0x79, 0x59, 0x60, 0xb0, 0x46, 0x85, 0x6a, 0x30, 0xd3, 0x8e, 0xc2, + 0x84, 0xdb, 0xdd, 0x6a, 0xdc, 0x47, 0x61, 0xd8, 0x0c, 0x4e, 0x6a, 0x64, 0xf0, 0xb8, 0xab, 0x04, + 0x7a, 0x1e, 0xc6, 0x45, 0xc0, 0x52, 0x23, 0x0c, 0x7d, 0x61, 0xa5, 0x51, 0x37, 0xde, 0xcd, 0x14, + 0x85, 0x75, 0x3a, 0xad, 0x18, 0x33, 0xe6, 0x8d, 0xe6, 0x16, 0xe3, 0x06, 0x3d, 0x8d, 0x2e, 0x93, + 0xdb, 0x62, 0x6c, 0xa0, 0xdc, 0x16, 0xa9, 0xdd, 0xaa, 0x32, 0xf0, 0xfd, 0x05, 0xf4, 0xb5, 0xf4, + 0x7c, 0xa3, 0x0c, 0x23, 0x7c, 0x28, 0x8e, 0x41, 0x15, 0x5b, 0x13, 0xb6, 0x9b, 0x1e, 0x19, 0x05, + 0x78, 0x5b, 0x16, 0x6a, 0x4e, 0xe2, 0x70, 0x31, 0xa4, 0x56, 0x43, 0x6a, 0xe5, 0x41, 0x0b, 0xc6, + 0x7a, 0x99, 0xcb, 0x18, 0x27, 0x80, 0xf3, 0xd0, 0x56, 0xcf, 0xdb, 0x00, 0x31, 0x7b, 0x5d, 0x94, + 0xf2, 0x10, 0x19, 0x50, 0x9f, 0xe8, 0x51, 0x7b, 0x53, 0x11, 0xf3, 0x36, 0xa4, 0x53, 0x50, 0x21, + 0xb0, 0xc6, 0x71, 0xee, 0x05, 0xa8, 0x28, 0xe2, 0x7e, 0x27, 0xb9, 0x09, 0x5d, 0x78, 0x7d, 0x0a, + 0xa6, 0x33, 0x75, 0x1d, 0xe9, 0x20, 0xf8, 0xdb, 0x16, 0x4c, 0xf3, 0x26, 0xaf, 0x06, 0x7b, 0x62, + 0xb1, 0xbf, 0x07, 0x27, 0xfd, 0x9c, 0x45, 0x27, 0x46, 0x74, 0xf0, 0x45, 0xaa, 0x0e, 0x7e, 0x79, + 0x58, 0x9c, 0x5b, 0x07, 0x3d, 0xfc, 0xf3, 0x77, 0x91, 0x1d, 0x5f, 0x78, 0x20, 0x4f, 0xf0, 0xcc, + 0xd0, 0x1c, 0x86, 0x15, 0xd6, 0xfe, 0x9e, 0x05, 0xb3, 0x5d, 0xaf, 0xea, 0x7f, 0xa0, 0x6d, 0x17, + 0x89, 0xaf, 0x4b, 0x05, 0x89, 0xaf, 0xf5, 0x4f, 0x2b, 0xf7, 0xfc, 0xb4, 0x5f, 0xb3, 0x40, 0xcc, + 0xc0, 0x63, 0x50, 0xe7, 0x3f, 0x6d, 0xaa, 0xf3, 0x73, 0xc5, 0x93, 0xba, 0x40, 0x8f, 0xff, 0x0b, + 0x0b, 0x66, 0x38, 0x41, 0x7a, 0x79, 0xf1, 0x81, 0x8e, 0xc3, 0x20, 0xaf, 0xb1, 0xa8, 0xe7, 0x2f, + 0xf3, 0x3f, 0xca, 0x18, 0xac, 0xa1, 0x9e, 0x83, 0xe5, 0xca, 0x05, 0x74, 0x84, 0x57, 0x86, 0x8e, + 0x9c, 0xab, 0xcd, 0xfe, 0x53, 0x0b, 0x10, 0xaf, 0x26, 0xfb, 0x20, 0x35, 0xdf, 0xfa, 0xb4, 0x03, + 0x7d, 0x2a, 0x6a, 0x14, 0x06, 0x6b, 0x54, 0x77, 0xa5, 0x7b, 0x32, 0x37, 0x50, 0xe5, 0xfe, 0x37, + 0x50, 0x47, 0xe8, 0xd1, 0xbf, 0x31, 0x04, 0x59, 0x77, 0x47, 0x74, 0x03, 0x26, 0x5a, 0x4e, 0xdb, + 0xd9, 0xf0, 0x7c, 0x2f, 0xf1, 0x48, 0xdc, 0xeb, 0xea, 0x7a, 0x45, 0xa3, 0x13, 0xd7, 0x3d, 0x1a, + 0x04, 0x1b, 0x7c, 0xd0, 0x02, 0x40, 0x3b, 0xf2, 0xf6, 0x3c, 0x9f, 0x6c, 0xb1, 0x13, 0x0d, 0x8b, + 0x79, 0xe0, 0xf7, 0xb1, 0x12, 0x8a, 0x35, 0x8a, 0x1c, 0x1f, 0xf9, 0xf2, 0xbd, 0xf3, 0x91, 0x1f, + 0x3a, 0xa2, 0x8f, 0xfc, 0xf0, 0x40, 0x3e, 0xf2, 0x18, 0xee, 0x93, 0x7b, 0x37, 0xfd, 0xbf, 0xe6, + 0xf9, 0x44, 0x28, 0x6c, 0x3c, 0x12, 0x62, 0xee, 0xf6, 0xc1, 0xfc, 0x7d, 0x38, 0x97, 0x02, 0x17, + 0x94, 0x44, 0x3f, 0x09, 0x55, 0xc7, 0xf7, 0xc3, 0x9b, 0xaa, 0xd7, 0x56, 0xe3, 0x96, 0xe3, 0xa7, + 0xa9, 0x4b, 0xc7, 0x96, 0x1f, 0xbc, 0x7d, 0x30, 0x5f, 0x5d, 0x2a, 0xa0, 0xc1, 0x85, 0xa5, 0xed, + 0x1d, 0x38, 0xd1, 0x24, 0x91, 0x7c, 0xb8, 0x4c, 0x2d, 0xb1, 0x75, 0xa8, 0x44, 0x19, 0xa1, 0x32, + 0x50, 0xb8, 0xbc, 0x96, 0x30, 0x4c, 0x0a, 0x91, 0x94, 0x91, 0xfd, 0xe7, 0x16, 0x8c, 0x0a, 0x17, + 0xca, 0x63, 0xd0, 0x65, 0x96, 0x0c, 0xb3, 0xd2, 0x7c, 0xbe, 0xe0, 0x65, 0x8d, 0x29, 0x34, 0x28, + 0xd5, 0x33, 0x06, 0xa5, 0x87, 0x7b, 0x31, 0xe9, 0x6d, 0x4a, 0xfa, 0xc5, 0x32, 0x4c, 0x99, 0xee, + 0xa3, 0xc7, 0xd0, 0x05, 0x57, 0x61, 0x34, 0x16, 0xbe, 0xca, 0xa5, 0x62, 0x9f, 0xb7, 0xec, 0x20, + 0xa6, 0x37, 0xe3, 0xc2, 0x3b, 0x59, 0x32, 0xc9, 0x75, 0x82, 0x2e, 0xdf, 0x43, 0x27, 0xe8, 0x7e, + 0x1e, 0xbc, 0x43, 0x77, 0xc3, 0x83, 0xd7, 0xfe, 0x26, 0x13, 0xfe, 0x3a, 0xfc, 0x18, 0xf4, 0x82, + 0x0b, 0xe6, 0x36, 0x61, 0xf7, 0x98, 0x59, 0xa2, 0x51, 0x05, 0xfa, 0xc1, 0x3f, 0xb1, 0x60, 0x5c, + 0x10, 0x1e, 0x43, 0xb3, 0x3f, 0x63, 0x36, 0xfb, 0x81, 0x1e, 0xcd, 0x2e, 0x68, 0xef, 0xdf, 0x2d, + 0xa9, 0xf6, 0x36, 0xc2, 0x28, 0x19, 0x28, 0x95, 0xf5, 0x18, 0x3d, 0x0d, 0x86, 0xad, 0xd0, 0x17, + 0x9b, 0xf9, 0x83, 0x69, 0x30, 0x1c, 0x87, 0x1f, 0x6a, 0xbf, 0xb1, 0xa2, 0x66, 0xb1, 0x5a, 0x61, + 0x94, 0x88, 0x0d, 0x34, 0x8d, 0xd5, 0x0a, 0xa3, 0x04, 0x33, 0x0c, 0x72, 0x01, 0xd2, 0x17, 0xdd, + 0x45, 0xf4, 0x68, 0xf1, 0x2a, 0xec, 0x24, 0x9e, 0xbf, 0xe0, 0x05, 0x49, 0x9c, 0x44, 0x0b, 0xf5, + 0x20, 0xb9, 0x16, 0xf1, 0xb3, 0x81, 0x16, 0xdd, 0xa6, 0x78, 0x61, 0x8d, 0xaf, 0x0c, 0xaf, 0x60, + 0x75, 0x0c, 0x9b, 0xf7, 0x3d, 0x57, 0x05, 0x1c, 0x2b, 0x0a, 0xfb, 0x05, 0x26, 0x93, 0x59, 0x07, + 0x1d, 0x2d, 0xf0, 0xec, 0x3b, 0x63, 0xaa, 0x6b, 0x99, 0xb1, 0xb7, 0xa6, 0x87, 0xb7, 0xf5, 0x16, + 0x81, 0xb4, 0x62, 0xdd, 0x95, 0x38, 0x8d, 0x81, 0x43, 0x9f, 0xed, 0xba, 0x06, 0x7c, 0xba, 0x8f, + 0x2c, 0x3d, 0xc2, 0xc5, 0x1f, 0xcb, 0xcc, 0xc7, 0x32, 0x98, 0xd5, 0x1b, 0xd9, 0x64, 0xe3, 0x2b, + 0x12, 0x81, 0x53, 0x1a, 0xb4, 0x28, 0x4e, 0x96, 0xdc, 0xcc, 0xf2, 0x40, 0xe6, 0x64, 0x29, 0x3f, + 0x5f, 0x3b, 0x5a, 0x3e, 0x03, 0xe3, 0xea, 0x01, 0x97, 0x06, 0x7f, 0x07, 0xa3, 0xc2, 0x75, 0xa9, + 0xd5, 0x14, 0x8c, 0x75, 0x1a, 0xb4, 0x0e, 0xd3, 0x31, 0x7f, 0x5d, 0x46, 0x46, 0x3c, 0x08, 0xbb, + 0xc1, 0x13, 0x99, 0xb7, 0xe3, 0x25, 0xfa, 0x90, 0x81, 0xf8, 0x62, 0x95, 0x31, 0x12, 0x59, 0x16, + 0xe8, 0x15, 0x98, 0xf2, 0xf5, 0x57, 0x36, 0x1b, 0xc2, 0xac, 0xa0, 0x5c, 0xb9, 0x8c, 0x37, 0x38, + 0x1b, 0x38, 0x43, 0x4d, 0x95, 0x00, 0x1d, 0x22, 0x12, 0xe8, 0x38, 0xc1, 0x16, 0x89, 0xc5, 0xf3, + 0x13, 0x4c, 0x09, 0xb8, 0x5c, 0x40, 0x83, 0x0b, 0x4b, 0xa3, 0x17, 0x61, 0x42, 0x7e, 0xbe, 0x16, + 0x01, 0x94, 0x3a, 0x0c, 0x6a, 0x38, 0x6c, 0x50, 0xa2, 0x9b, 0x70, 0x4a, 0xfe, 0x5f, 0x8f, 0x9c, + 0xcd, 0x4d, 0xaf, 0x25, 0x02, 0xb0, 0xc6, 0x19, 0x8b, 0x25, 0xe9, 0x3d, 0xbd, 0x9a, 0x47, 0x74, + 0x78, 0x30, 0x7f, 0x56, 0xf4, 0x5a, 0x2e, 0x9e, 0x0d, 0x62, 0x3e, 0x7f, 0x74, 0x05, 0x4e, 0x6c, + 0x13, 0xc7, 0x4f, 0xb6, 0x57, 0xb6, 0x49, 0x6b, 0x47, 0x2e, 0x22, 0x16, 0x57, 0xa4, 0xb9, 0xd9, + 0x5d, 0xec, 0x26, 0xc1, 0x79, 0xe5, 0xd0, 0x5b, 0x50, 0x6d, 0x77, 0x36, 0x7c, 0x2f, 0xde, 0xbe, + 0x1a, 0x26, 0xec, 0xc6, 0x52, 0xbd, 0x7f, 0x22, 0x02, 0x90, 0x54, 0x4c, 0x55, 0xa3, 0x80, 0x0e, + 0x17, 0x72, 0x40, 0xef, 0xc1, 0xa9, 0xcc, 0x64, 0xe0, 0x4f, 0xea, 0x88, 0x40, 0xa5, 0xc7, 0xf3, + 0x97, 0x53, 0x4e, 0x01, 0x1e, 0x16, 0x97, 0x8b, 0xc2, 0xf9, 0x55, 0xbc, 0xbf, 0x7b, 0xec, 0x77, + 0x69, 0x61, 0x4d, 0xbb, 0x41, 0x9f, 0x83, 0x09, 0x7d, 0x16, 0x89, 0x0d, 0xe6, 0xd1, 0x7e, 0x2f, + 0xca, 0x0a, 0xdd, 0x48, 0xcd, 0x28, 0x1d, 0x87, 0x0d, 0x8e, 0x36, 0x81, 0xfc, 0xef, 0x43, 0x97, + 0x61, 0xac, 0xe5, 0x7b, 0x24, 0x48, 0xea, 0x8d, 0x5e, 0x81, 0xb3, 0x2b, 0x82, 0x46, 0x74, 0x98, + 0xc8, 0xdf, 0xc4, 0x61, 0x58, 0x71, 0xb0, 0x7f, 0xbf, 0x04, 0xf3, 0x7d, 0x52, 0x78, 0x65, 0x6c, + 0x80, 0xd6, 0x40, 0x36, 0xc0, 0x25, 0xf9, 0x9a, 0xcb, 0xd5, 0xcc, 0xf9, 0x33, 0xf3, 0x52, 0x4b, + 0x7a, 0x0a, 0xcd, 0xd2, 0x0f, 0xec, 0xfe, 0xa6, 0x9b, 0x11, 0x87, 0xfa, 0x7a, 0x01, 0x36, 0x74, + 0x7b, 0xf0, 0xf0, 0xe0, 0x1a, 0x7d, 0xa1, 0x29, 0xd8, 0xfe, 0x66, 0x09, 0x4e, 0xa9, 0x2e, 0xfc, + 0xf1, 0xed, 0xb8, 0xeb, 0xdd, 0x1d, 0x77, 0x17, 0x0c, 0xe9, 0xf6, 0x35, 0x18, 0x69, 0xee, 0xc7, + 0xad, 0xc4, 0x1f, 0x40, 0x01, 0x7a, 0xc4, 0x58, 0xa0, 0xe9, 0x36, 0xcd, 0x1e, 0x64, 0x13, 0xeb, + 0xd5, 0xfe, 0xab, 0x16, 0x4c, 0xaf, 0xaf, 0x34, 0x9a, 0x61, 0x6b, 0x87, 0x24, 0x4b, 0xdc, 0x4c, + 0x84, 0x85, 0xfe, 0x63, 0xdd, 0xa1, 0x5e, 0x93, 0xa7, 0x31, 0x9d, 0x85, 0xa1, 0xed, 0x30, 0x4e, + 0xb2, 0x97, 0x25, 0x17, 0xc3, 0x38, 0xc1, 0x0c, 0x63, 0xff, 0xb1, 0x05, 0xc3, 0xec, 0x0d, 0xb2, + 0x7e, 0x6f, 0xd5, 0x0d, 0xf2, 0x5d, 0xe8, 0x79, 0x18, 0x21, 0x9b, 0x9b, 0xa4, 0x95, 0x88, 0x51, + 0x95, 0x11, 0x39, 0x23, 0xab, 0x0c, 0x4a, 0x37, 0x7d, 0x56, 0x19, 0xff, 0x8b, 0x05, 0x31, 0xfa, + 0x2c, 0x54, 0x12, 0x6f, 0x97, 0x2c, 0xb9, 0xae, 0xb8, 0xa7, 0x38, 0x9a, 0x4b, 0x9a, 0x52, 0x42, + 0xd6, 0x25, 0x13, 0x9c, 0xf2, 0xb3, 0x7f, 0xbe, 0x04, 0x90, 0x46, 0xee, 0xf5, 0xfb, 0xcc, 0xe5, + 0xae, 0x27, 0xf9, 0x1e, 0xcd, 0x79, 0x92, 0x0f, 0xa5, 0x0c, 0x73, 0x1e, 0xe4, 0x53, 0x5d, 0x55, + 0x1e, 0xa8, 0xab, 0x86, 0x8e, 0xd2, 0x55, 0x2b, 0x30, 0x9b, 0x46, 0x1e, 0x9a, 0x61, 0xd8, 0x2c, + 0x5d, 0xef, 0x7a, 0x16, 0x89, 0xbb, 0xe9, 0xed, 0x2f, 0x59, 0x20, 0xdc, 0x94, 0x07, 0x98, 0xd0, + 0x6f, 0xca, 0xd7, 0xb3, 0x8c, 0xbc, 0x82, 0x67, 0x8b, 0xfd, 0xb6, 0x45, 0x36, 0x41, 0xb5, 0x81, + 0x18, 0x39, 0x04, 0x0d, 0x5e, 0xf6, 0xef, 0x5a, 0x30, 0xce, 0xd1, 0x2c, 0x67, 0xdd, 0x00, 0xad, + 0x39, 0x52, 0xb2, 0x67, 0xf6, 0xb0, 0x14, 0x65, 0xac, 0x72, 0x02, 0xeb, 0x0f, 0x4b, 0x49, 0x04, + 0x4e, 0x69, 0xd0, 0xe3, 0x30, 0x1a, 0x77, 0x36, 0x18, 0x79, 0xc6, 0x53, 0xb9, 0xc9, 0xc1, 0x58, + 0xe2, 0xe9, 0xbc, 0x9a, 0xc9, 0x3a, 0xaa, 0xa3, 0x8b, 0x30, 0xc2, 0xc5, 0x86, 0x58, 0xc6, 0x3d, + 0x6e, 0x65, 0x34, 0xf7, 0x76, 0xe0, 0x2f, 0xa1, 0x33, 0x71, 0x23, 0xca, 0xa3, 0xb7, 0x60, 0xdc, + 0x0d, 0x6f, 0x06, 0x37, 0x9d, 0xc8, 0x5d, 0x6a, 0xd4, 0x45, 0xaf, 0xe7, 0x6a, 0x1f, 0xb5, 0x94, + 0x4c, 0x77, 0x99, 0x67, 0x16, 0xc8, 0x14, 0x85, 0x75, 0x76, 0x68, 0x9d, 0x25, 0x43, 0xe1, 0xef, + 0xb3, 0xf6, 0x72, 0xc0, 0x51, 0x4f, 0xba, 0x6a, 0x9c, 0x27, 0x45, 0xc6, 0x14, 0xf1, 0xba, 0x6b, + 0xca, 0xc8, 0xfe, 0xc2, 0x09, 0x30, 0x46, 0xdb, 0x48, 0xc9, 0x6c, 0xdd, 0xa5, 0x94, 0xcc, 0x18, + 0xc6, 0xc8, 0x6e, 0x3b, 0xd9, 0xaf, 0x79, 0x51, 0xaf, 0x1c, 0xf9, 0xab, 0x82, 0xa6, 0x9b, 0xa7, + 0xc4, 0x60, 0xc5, 0x27, 0x3f, 0x6f, 0x76, 0xf9, 0x03, 0xcc, 0x9b, 0x3d, 0x74, 0x8c, 0x79, 0xb3, + 0xaf, 0xc2, 0xe8, 0x96, 0x97, 0x60, 0xd2, 0x0e, 0xc5, 0x96, 0x99, 0x3b, 0x13, 0x2e, 0x70, 0x92, + 0xee, 0xec, 0xae, 0x02, 0x81, 0x25, 0x13, 0xf4, 0xaa, 0x5a, 0x03, 0x23, 0xc5, 0x1a, 0x67, 0xb7, + 0x01, 0x3f, 0x77, 0x15, 0x88, 0x3c, 0xd9, 0xa3, 0x77, 0x9a, 0x27, 0x5b, 0xe5, 0xb9, 0x1e, 0x7b, + 0x7f, 0x79, 0xae, 0x8d, 0x3c, 0xe0, 0x95, 0xbb, 0x97, 0x07, 0xfc, 0x4b, 0x16, 0x9c, 0x6a, 0xe7, + 0xa5, 0xc4, 0x17, 0x19, 0xab, 0x9f, 0x1f, 0xf8, 0x69, 0x00, 0xa3, 0x42, 0x76, 0xf4, 0xc8, 0x25, + 0xc3, 0xf9, 0xd5, 0xc9, 0x84, 0xe2, 0xe3, 0x77, 0x9a, 0x50, 0xfc, 0xde, 0xa4, 0xb6, 0x4e, 0xd3, + 0x8b, 0x4f, 0xbe, 0xef, 0xf4, 0xe2, 0xaf, 0xaa, 0xf4, 0xe2, 0x3d, 0x52, 0x4e, 0xf0, 0xe4, 0xe1, + 0x7d, 0x93, 0x8a, 0x6b, 0x89, 0xc1, 0xa7, 0xef, 0x46, 0x62, 0xf0, 0xb7, 0x4d, 0x61, 0xcf, 0xb3, + 0x54, 0x3f, 0xd9, 0x47, 0xd8, 0x1b, 0x7c, 0x7b, 0x8b, 0x7b, 0x9e, 0x04, 0x7d, 0xf6, 0x8e, 0x92, + 0xa0, 0xdf, 0xd0, 0xd3, 0x8b, 0xa3, 0x3e, 0xf9, 0xb3, 0x29, 0xd1, 0x80, 0x49, 0xc5, 0x6f, 0xe8, + 0x5b, 0xd0, 0x89, 0x62, 0xbe, 0x6a, 0xa7, 0xe9, 0xe6, 0x9b, 0xb7, 0x09, 0x75, 0x27, 0x2b, 0x3f, + 0x79, 0x3c, 0xc9, 0xca, 0x4f, 0xdd, 0xf5, 0x64, 0xe5, 0xf7, 0x1d, 0x43, 0xb2, 0xf2, 0xfb, 0x3f, + 0xd0, 0x64, 0xe5, 0xd5, 0x7b, 0x9b, 0xac, 0xfc, 0xf4, 0xdd, 0x48, 0x56, 0x7e, 0x03, 0x2a, 0x6d, + 0x19, 0xcb, 0x58, 0x9d, 0x2b, 0x1e, 0x92, 0xdc, 0x80, 0x47, 0x3e, 0x24, 0x0a, 0x85, 0x53, 0x56, + 0x94, 0x6f, 0x9a, 0xbc, 0xfc, 0x81, 0x1e, 0xc6, 0xa5, 0xbc, 0x63, 0x7b, 0x8f, 0x94, 0xe5, 0x7f, + 0xad, 0x04, 0x67, 0x7a, 0xcf, 0xeb, 0xf4, 0xcc, 0xdf, 0x48, 0x6d, 0xd4, 0x99, 0x33, 0x3f, 0x53, + 0xba, 0x34, 0xaa, 0x81, 0x03, 0xbe, 0x2f, 0xc0, 0xac, 0x72, 0xe9, 0xf2, 0xbd, 0xd6, 0xbe, 0xf6, + 0xde, 0x90, 0x8a, 0x12, 0x68, 0x66, 0x09, 0x70, 0x77, 0x19, 0xb4, 0x04, 0xd3, 0x06, 0xb0, 0x5e, + 0x13, 0x2a, 0xb9, 0x32, 0x32, 0x34, 0x4d, 0x34, 0xce, 0xd2, 0xdb, 0x5f, 0xb3, 0xe0, 0xfe, 0x82, + 0x0c, 0xa6, 0x03, 0xc7, 0x33, 0x6f, 0xc2, 0x74, 0xdb, 0x2c, 0xda, 0x27, 0xed, 0x81, 0x91, 0x27, + 0x55, 0xb5, 0x35, 0x83, 0xc0, 0x59, 0xa6, 0xcb, 0xe7, 0xbe, 0xf5, 0xfd, 0x33, 0x1f, 0xf9, 0xc3, + 0xef, 0x9f, 0xf9, 0xc8, 0xf7, 0xbe, 0x7f, 0xe6, 0x23, 0x7f, 0xe9, 0xf6, 0x19, 0xeb, 0x5b, 0xb7, + 0xcf, 0x58, 0x7f, 0x78, 0xfb, 0x8c, 0xf5, 0xbd, 0xdb, 0x67, 0xac, 0x3f, 0xb9, 0x7d, 0xc6, 0xfa, + 0xf9, 0x1f, 0x9c, 0xf9, 0xc8, 0x9b, 0xa5, 0xbd, 0x67, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xd5, 0x56, 0x3b, 0x3d, 0xc8, 0xce, 0x00, 0x00, } diff --git a/staging/src/k8s.io/api/core/v1/generated.proto b/staging/src/k8s.io/api/core/v1/generated.proto index fda350d46c7..7970fecc026 100644 --- a/staging/src/k8s.io/api/core/v1/generated.proto +++ b/staging/src/k8s.io/api/core/v1/generated.proto @@ -21,6 +21,7 @@ syntax = 'proto2'; package k8s.io.api.core.v1; +import "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto"; import "k8s.io/apimachinery/pkg/api/resource/generated.proto"; import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/generated.proto"; diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go index 18eecdb5078..e9b16e6db84 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.pb.go @@ -31,6 +31,13 @@ limitations under the License. CustomResourceDefinitionNames CustomResourceDefinitionSpec CustomResourceDefinitionStatus + CustomResourceValidation + ExternalDocumentation + JSON + JSONSchemaProps + JSONSchemaPropsOrArray + JSONSchemaPropsOrBool + JSONSchemaPropsOrStringArray */ package v1beta1 @@ -38,6 +45,8 @@ import proto "github.com/gogo/protobuf/proto" import fmt "fmt" import math "math" +import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" + import strings "strings" import reflect "reflect" @@ -90,6 +99,38 @@ func (*CustomResourceDefinitionStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} } +func (m *CustomResourceValidation) Reset() { *m = CustomResourceValidation{} } +func (*CustomResourceValidation) ProtoMessage() {} +func (*CustomResourceValidation) Descriptor() ([]byte, []int) { + return fileDescriptorGenerated, []int{6} +} + +func (m *ExternalDocumentation) Reset() { *m = ExternalDocumentation{} } +func (*ExternalDocumentation) ProtoMessage() {} +func (*ExternalDocumentation) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} } + +func (m *JSON) Reset() { *m = JSON{} } +func (*JSON) ProtoMessage() {} +func (*JSON) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} } + +func (m *JSONSchemaProps) Reset() { *m = JSONSchemaProps{} } +func (*JSONSchemaProps) ProtoMessage() {} +func (*JSONSchemaProps) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} } + +func (m *JSONSchemaPropsOrArray) Reset() { *m = JSONSchemaPropsOrArray{} } +func (*JSONSchemaPropsOrArray) ProtoMessage() {} +func (*JSONSchemaPropsOrArray) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} } + +func (m *JSONSchemaPropsOrBool) Reset() { *m = JSONSchemaPropsOrBool{} } +func (*JSONSchemaPropsOrBool) ProtoMessage() {} +func (*JSONSchemaPropsOrBool) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} } + +func (m *JSONSchemaPropsOrStringArray) Reset() { *m = JSONSchemaPropsOrStringArray{} } +func (*JSONSchemaPropsOrStringArray) ProtoMessage() {} +func (*JSONSchemaPropsOrStringArray) Descriptor() ([]byte, []int) { + return fileDescriptorGenerated, []int{12} +} + func init() { proto.RegisterType((*CustomResourceDefinition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinition") proto.RegisterType((*CustomResourceDefinitionCondition)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionCondition") @@ -97,6 +138,13 @@ func init() { proto.RegisterType((*CustomResourceDefinitionNames)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionNames") proto.RegisterType((*CustomResourceDefinitionSpec)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionSpec") proto.RegisterType((*CustomResourceDefinitionStatus)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceDefinitionStatus") + proto.RegisterType((*CustomResourceValidation)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.CustomResourceValidation") + proto.RegisterType((*ExternalDocumentation)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.ExternalDocumentation") + proto.RegisterType((*JSON)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSON") + proto.RegisterType((*JSONSchemaProps)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaProps") + proto.RegisterType((*JSONSchemaPropsOrArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrArray") + proto.RegisterType((*JSONSchemaPropsOrBool)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrBool") + proto.RegisterType((*JSONSchemaPropsOrStringArray)(nil), "k8s.io.apiextensions_apiserver.pkg.apis.apiextensions.v1beta1.JSONSchemaPropsOrStringArray") } func (m *CustomResourceDefinition) Marshal() (dAtA []byte, err error) { size := m.Size() @@ -304,6 +352,16 @@ func (m *CustomResourceDefinitionSpec) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintGenerated(dAtA, i, uint64(len(m.Scope))) i += copy(dAtA[i:], m.Scope) + if m.Validation != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Validation.Size())) + n7, err := m.Validation.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } return i, nil } @@ -337,11 +395,628 @@ func (m *CustomResourceDefinitionStatus) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintGenerated(dAtA, i, uint64(m.AcceptedNames.Size())) - n7, err := m.AcceptedNames.MarshalTo(dAtA[i:]) + n8, err := m.AcceptedNames.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n7 + i += n8 + return i, nil +} + +func (m *CustomResourceValidation) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CustomResourceValidation) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.OpenAPIV3Schema != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.OpenAPIV3Schema.Size())) + n9, err := m.OpenAPIV3Schema.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 + } + return i, nil +} + +func (m *ExternalDocumentation) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalDocumentation) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description))) + i += copy(dAtA[i:], m.Description) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.URL))) + i += copy(dAtA[i:], m.URL) + return i, nil +} + +func (m *JSON) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JSON) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Raw != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw))) + i += copy(dAtA[i:], m.Raw) + } + return i, nil +} + +func (m *JSONSchemaProps) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JSONSchemaProps) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.ID))) + i += copy(dAtA[i:], m.ID) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Schema))) + i += copy(dAtA[i:], m.Schema) + if m.Ref != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Ref))) + i += copy(dAtA[i:], *m.Ref) + } + dAtA[i] = 0x22 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description))) + i += copy(dAtA[i:], m.Description) + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) + i += copy(dAtA[i:], m.Type) + dAtA[i] = 0x32 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Format))) + i += copy(dAtA[i:], m.Format) + dAtA[i] = 0x3a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Title))) + i += copy(dAtA[i:], m.Title) + if m.Default != nil { + dAtA[i] = 0x42 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Default.Size())) + n10, err := m.Default.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if m.Maximum != nil { + dAtA[i] = 0x49 + i++ + i = encodeFixed64Generated(dAtA, i, uint64(math.Float64bits(float64(*m.Maximum)))) + } + dAtA[i] = 0x50 + i++ + if m.ExclusiveMaximum { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + if m.Minimum != nil { + dAtA[i] = 0x59 + i++ + i = encodeFixed64Generated(dAtA, i, uint64(math.Float64bits(float64(*m.Minimum)))) + } + dAtA[i] = 0x60 + i++ + if m.ExclusiveMinimum { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + if m.MaxLength != nil { + dAtA[i] = 0x68 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxLength)) + } + if m.MinLength != nil { + dAtA[i] = 0x70 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.MinLength)) + } + dAtA[i] = 0x7a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Pattern))) + i += copy(dAtA[i:], m.Pattern) + if m.MaxItems != nil { + dAtA[i] = 0x80 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxItems)) + } + if m.MinItems != nil { + dAtA[i] = 0x88 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.MinItems)) + } + dAtA[i] = 0x90 + i++ + dAtA[i] = 0x1 + i++ + if m.UniqueItems { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + if m.MultipleOf != nil { + dAtA[i] = 0x99 + i++ + dAtA[i] = 0x1 + i++ + i = encodeFixed64Generated(dAtA, i, uint64(math.Float64bits(float64(*m.MultipleOf)))) + } + if len(m.Enum) > 0 { + for _, msg := range m.Enum { + dAtA[i] = 0xa2 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.MaxProperties != nil { + dAtA[i] = 0xa8 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.MaxProperties)) + } + if m.MinProperties != nil { + dAtA[i] = 0xb0 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.MinProperties)) + } + if len(m.Required) > 0 { + for _, s := range m.Required { + dAtA[i] = 0xba + i++ + dAtA[i] = 0x1 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.Items != nil { + dAtA[i] = 0xc2 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Items.Size())) + n11, err := m.Items.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } + if len(m.AllOf) > 0 { + for _, msg := range m.AllOf { + dAtA[i] = 0xca + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.OneOf) > 0 { + for _, msg := range m.OneOf { + dAtA[i] = 0xd2 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.AnyOf) > 0 { + for _, msg := range m.AnyOf { + dAtA[i] = 0xda + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Not != nil { + dAtA[i] = 0xe2 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Not.Size())) + n12, err := m.Not.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n12 + } + if len(m.Properties) > 0 { + keysForProperties := make([]string, 0, len(m.Properties)) + for k := range m.Properties { + keysForProperties = append(keysForProperties, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForProperties) + for _, k := range keysForProperties { + dAtA[i] = 0xea + i++ + dAtA[i] = 0x1 + i++ + v := m.Properties[string(k)] + msgSize := 0 + if (&v) != nil { + msgSize = (&v).Size() + msgSize += 1 + sovGenerated(uint64(msgSize)) + } + mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize + i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64((&v).Size())) + n13, err := (&v).MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n13 + } + } + if m.AdditionalProperties != nil { + dAtA[i] = 0xf2 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.AdditionalProperties.Size())) + n14, err := m.AdditionalProperties.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n14 + } + if len(m.PatternProperties) > 0 { + keysForPatternProperties := make([]string, 0, len(m.PatternProperties)) + for k := range m.PatternProperties { + keysForPatternProperties = append(keysForPatternProperties, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForPatternProperties) + for _, k := range keysForPatternProperties { + dAtA[i] = 0xfa + i++ + dAtA[i] = 0x1 + i++ + v := m.PatternProperties[string(k)] + msgSize := 0 + if (&v) != nil { + msgSize = (&v).Size() + msgSize += 1 + sovGenerated(uint64(msgSize)) + } + mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize + i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64((&v).Size())) + n15, err := (&v).MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n15 + } + } + if len(m.Dependencies) > 0 { + keysForDependencies := make([]string, 0, len(m.Dependencies)) + for k := range m.Dependencies { + keysForDependencies = append(keysForDependencies, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForDependencies) + for _, k := range keysForDependencies { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x2 + i++ + v := m.Dependencies[string(k)] + msgSize := 0 + if (&v) != nil { + msgSize = (&v).Size() + msgSize += 1 + sovGenerated(uint64(msgSize)) + } + mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize + i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64((&v).Size())) + n16, err := (&v).MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n16 + } + } + if m.AdditionalItems != nil { + dAtA[i] = 0x8a + i++ + dAtA[i] = 0x2 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.AdditionalItems.Size())) + n17, err := m.AdditionalItems.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n17 + } + if len(m.Definitions) > 0 { + keysForDefinitions := make([]string, 0, len(m.Definitions)) + for k := range m.Definitions { + keysForDefinitions = append(keysForDefinitions, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForDefinitions) + for _, k := range keysForDefinitions { + dAtA[i] = 0x92 + i++ + dAtA[i] = 0x2 + i++ + v := m.Definitions[string(k)] + msgSize := 0 + if (&v) != nil { + msgSize = (&v).Size() + msgSize += 1 + sovGenerated(uint64(msgSize)) + } + mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize + i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64((&v).Size())) + n18, err := (&v).MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n18 + } + } + if m.ExternalDocs != nil { + dAtA[i] = 0x9a + i++ + dAtA[i] = 0x2 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.ExternalDocs.Size())) + n19, err := m.ExternalDocs.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n19 + } + if m.Example != nil { + dAtA[i] = 0xa2 + i++ + dAtA[i] = 0x2 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Example.Size())) + n20, err := m.Example.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n20 + } + return i, nil +} + +func (m *JSONSchemaPropsOrArray) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JSONSchemaPropsOrArray) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Schema != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size())) + n21, err := m.Schema.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n21 + } + if len(m.JSONSchemas) > 0 { + for _, msg := range m.JSONSchemas { + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *JSONSchemaPropsOrBool) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JSONSchemaPropsOrBool) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0x8 + i++ + if m.Allows { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + if m.Schema != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size())) + n22, err := m.Schema.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n22 + } + return i, nil +} + +func (m *JSONSchemaPropsOrStringArray) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *JSONSchemaPropsOrStringArray) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Schema != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Schema.Size())) + n23, err := m.Schema.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n23 + } + if len(m.Property) > 0 { + for _, s := range m.Property { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } return i, nil } @@ -445,6 +1120,10 @@ func (m *CustomResourceDefinitionSpec) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) l = len(m.Scope) n += 1 + l + sovGenerated(uint64(l)) + if m.Validation != nil { + l = m.Validation.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -462,6 +1141,227 @@ func (m *CustomResourceDefinitionStatus) Size() (n int) { return n } +func (m *CustomResourceValidation) Size() (n int) { + var l int + _ = l + if m.OpenAPIV3Schema != nil { + l = m.OpenAPIV3Schema.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *ExternalDocumentation) Size() (n int) { + var l int + _ = l + l = len(m.Description) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.URL) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *JSON) Size() (n int) { + var l int + _ = l + if m.Raw != nil { + l = len(m.Raw) + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *JSONSchemaProps) Size() (n int) { + var l int + _ = l + l = len(m.ID) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Schema) + n += 1 + l + sovGenerated(uint64(l)) + if m.Ref != nil { + l = len(*m.Ref) + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.Description) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Format) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Title) + n += 1 + l + sovGenerated(uint64(l)) + if m.Default != nil { + l = m.Default.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if m.Maximum != nil { + n += 9 + } + n += 2 + if m.Minimum != nil { + n += 9 + } + n += 2 + if m.MaxLength != nil { + n += 1 + sovGenerated(uint64(*m.MaxLength)) + } + if m.MinLength != nil { + n += 1 + sovGenerated(uint64(*m.MinLength)) + } + l = len(m.Pattern) + n += 1 + l + sovGenerated(uint64(l)) + if m.MaxItems != nil { + n += 2 + sovGenerated(uint64(*m.MaxItems)) + } + if m.MinItems != nil { + n += 2 + sovGenerated(uint64(*m.MinItems)) + } + n += 3 + if m.MultipleOf != nil { + n += 10 + } + if len(m.Enum) > 0 { + for _, e := range m.Enum { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } + if m.MaxProperties != nil { + n += 2 + sovGenerated(uint64(*m.MaxProperties)) + } + if m.MinProperties != nil { + n += 2 + sovGenerated(uint64(*m.MinProperties)) + } + if len(m.Required) > 0 { + for _, s := range m.Required { + l = len(s) + n += 2 + l + sovGenerated(uint64(l)) + } + } + if m.Items != nil { + l = m.Items.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + if len(m.AllOf) > 0 { + for _, e := range m.AllOf { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } + if len(m.OneOf) > 0 { + for _, e := range m.OneOf { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } + if len(m.AnyOf) > 0 { + for _, e := range m.AnyOf { + l = e.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + } + if m.Not != nil { + l = m.Not.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + if len(m.Properties) > 0 { + for k, v := range m.Properties { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize)) + } + } + if m.AdditionalProperties != nil { + l = m.AdditionalProperties.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + if len(m.PatternProperties) > 0 { + for k, v := range m.PatternProperties { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize)) + } + } + if len(m.Dependencies) > 0 { + for k, v := range m.Dependencies { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize)) + } + } + if m.AdditionalItems != nil { + l = m.AdditionalItems.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + if len(m.Definitions) > 0 { + for k, v := range m.Definitions { + _ = k + _ = v + l = v.Size() + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l)) + n += mapEntrySize + 2 + sovGenerated(uint64(mapEntrySize)) + } + } + if m.ExternalDocs != nil { + l = m.ExternalDocs.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + if m.Example != nil { + l = m.Example.Size() + n += 2 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *JSONSchemaPropsOrArray) Size() (n int) { + var l int + _ = l + if m.Schema != nil { + l = m.Schema.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.JSONSchemas) > 0 { + for _, e := range m.JSONSchemas { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *JSONSchemaPropsOrBool) Size() (n int) { + var l int + _ = l + n += 2 + if m.Schema != nil { + l = m.Schema.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *JSONSchemaPropsOrStringArray) Size() (n int) { + var l int + _ = l + if m.Schema != nil { + l = m.Schema.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + if len(m.Property) > 0 { + for _, s := range m.Property { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + func sovGenerated(x uint64) (n int) { for { n++ @@ -535,6 +1435,7 @@ func (this *CustomResourceDefinitionSpec) String() string { `Version:` + fmt.Sprintf("%v", this.Version) + `,`, `Names:` + strings.Replace(strings.Replace(this.Names.String(), "CustomResourceDefinitionNames", "CustomResourceDefinitionNames", 1), `&`, ``, 1) + `,`, `Scope:` + fmt.Sprintf("%v", this.Scope) + `,`, + `Validation:` + strings.Replace(fmt.Sprintf("%v", this.Validation), "CustomResourceValidation", "CustomResourceValidation", 1) + `,`, `}`, }, "") return s @@ -550,6 +1451,155 @@ func (this *CustomResourceDefinitionStatus) String() string { }, "") return s } +func (this *CustomResourceValidation) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomResourceValidation{`, + `OpenAPIV3Schema:` + strings.Replace(fmt.Sprintf("%v", this.OpenAPIV3Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ExternalDocumentation) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ExternalDocumentation{`, + `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `URL:` + fmt.Sprintf("%v", this.URL) + `,`, + `}`, + }, "") + return s +} +func (this *JSON) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JSON{`, + `Raw:` + valueToStringGenerated(this.Raw) + `,`, + `}`, + }, "") + return s +} +func (this *JSONSchemaProps) String() string { + if this == nil { + return "nil" + } + keysForProperties := make([]string, 0, len(this.Properties)) + for k := range this.Properties { + keysForProperties = append(keysForProperties, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForProperties) + mapStringForProperties := "map[string]JSONSchemaProps{" + for _, k := range keysForProperties { + mapStringForProperties += fmt.Sprintf("%v: %v,", k, this.Properties[k]) + } + mapStringForProperties += "}" + keysForPatternProperties := make([]string, 0, len(this.PatternProperties)) + for k := range this.PatternProperties { + keysForPatternProperties = append(keysForPatternProperties, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForPatternProperties) + mapStringForPatternProperties := "map[string]JSONSchemaProps{" + for _, k := range keysForPatternProperties { + mapStringForPatternProperties += fmt.Sprintf("%v: %v,", k, this.PatternProperties[k]) + } + mapStringForPatternProperties += "}" + keysForDependencies := make([]string, 0, len(this.Dependencies)) + for k := range this.Dependencies { + keysForDependencies = append(keysForDependencies, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForDependencies) + mapStringForDependencies := "JSONSchemaDependencies{" + for _, k := range keysForDependencies { + mapStringForDependencies += fmt.Sprintf("%v: %v,", k, this.Dependencies[k]) + } + mapStringForDependencies += "}" + keysForDefinitions := make([]string, 0, len(this.Definitions)) + for k := range this.Definitions { + keysForDefinitions = append(keysForDefinitions, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForDefinitions) + mapStringForDefinitions := "JSONSchemaDefinitions{" + for _, k := range keysForDefinitions { + mapStringForDefinitions += fmt.Sprintf("%v: %v,", k, this.Definitions[k]) + } + mapStringForDefinitions += "}" + s := strings.Join([]string{`&JSONSchemaProps{`, + `ID:` + fmt.Sprintf("%v", this.ID) + `,`, + `Schema:` + fmt.Sprintf("%v", this.Schema) + `,`, + `Ref:` + valueToStringGenerated(this.Ref) + `,`, + `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Format:` + fmt.Sprintf("%v", this.Format) + `,`, + `Title:` + fmt.Sprintf("%v", this.Title) + `,`, + `Default:` + strings.Replace(fmt.Sprintf("%v", this.Default), "JSON", "JSON", 1) + `,`, + `Maximum:` + valueToStringGenerated(this.Maximum) + `,`, + `ExclusiveMaximum:` + fmt.Sprintf("%v", this.ExclusiveMaximum) + `,`, + `Minimum:` + valueToStringGenerated(this.Minimum) + `,`, + `ExclusiveMinimum:` + fmt.Sprintf("%v", this.ExclusiveMinimum) + `,`, + `MaxLength:` + valueToStringGenerated(this.MaxLength) + `,`, + `MinLength:` + valueToStringGenerated(this.MinLength) + `,`, + `Pattern:` + fmt.Sprintf("%v", this.Pattern) + `,`, + `MaxItems:` + valueToStringGenerated(this.MaxItems) + `,`, + `MinItems:` + valueToStringGenerated(this.MinItems) + `,`, + `UniqueItems:` + fmt.Sprintf("%v", this.UniqueItems) + `,`, + `MultipleOf:` + valueToStringGenerated(this.MultipleOf) + `,`, + `Enum:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Enum), "JSON", "JSON", 1), `&`, ``, 1) + `,`, + `MaxProperties:` + valueToStringGenerated(this.MaxProperties) + `,`, + `MinProperties:` + valueToStringGenerated(this.MinProperties) + `,`, + `Required:` + fmt.Sprintf("%v", this.Required) + `,`, + `Items:` + strings.Replace(fmt.Sprintf("%v", this.Items), "JSONSchemaPropsOrArray", "JSONSchemaPropsOrArray", 1) + `,`, + `AllOf:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllOf), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`, + `OneOf:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OneOf), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`, + `AnyOf:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AnyOf), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`, + `Not:` + strings.Replace(fmt.Sprintf("%v", this.Not), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`, + `Properties:` + mapStringForProperties + `,`, + `AdditionalProperties:` + strings.Replace(fmt.Sprintf("%v", this.AdditionalProperties), "JSONSchemaPropsOrBool", "JSONSchemaPropsOrBool", 1) + `,`, + `PatternProperties:` + mapStringForPatternProperties + `,`, + `Dependencies:` + mapStringForDependencies + `,`, + `AdditionalItems:` + strings.Replace(fmt.Sprintf("%v", this.AdditionalItems), "JSONSchemaPropsOrBool", "JSONSchemaPropsOrBool", 1) + `,`, + `Definitions:` + mapStringForDefinitions + `,`, + `ExternalDocs:` + strings.Replace(fmt.Sprintf("%v", this.ExternalDocs), "ExternalDocumentation", "ExternalDocumentation", 1) + `,`, + `Example:` + strings.Replace(fmt.Sprintf("%v", this.Example), "JSON", "JSON", 1) + `,`, + `}`, + }, "") + return s +} +func (this *JSONSchemaPropsOrArray) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JSONSchemaPropsOrArray{`, + `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`, + `JSONSchemas:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.JSONSchemas), "JSONSchemaProps", "JSONSchemaProps", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *JSONSchemaPropsOrBool) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JSONSchemaPropsOrBool{`, + `Allows:` + fmt.Sprintf("%v", this.Allows) + `,`, + `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`, + `}`, + }, "") + return s +} +func (this *JSONSchemaPropsOrStringArray) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JSONSchemaPropsOrStringArray{`, + `Schema:` + strings.Replace(fmt.Sprintf("%v", this.Schema), "JSONSchemaProps", "JSONSchemaProps", 1) + `,`, + `Property:` + fmt.Sprintf("%v", this.Property) + `,`, + `}`, + }, "") + return s +} func valueToStringGenerated(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1346,6 +2396,39 @@ func (m *CustomResourceDefinitionSpec) Unmarshal(dAtA []byte) error { } m.Scope = ResourceScope(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validation", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Validation == nil { + m.Validation = &CustomResourceValidation{} + } + if err := m.Validation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) @@ -1478,6 +2561,1995 @@ func (m *CustomResourceDefinitionStatus) Unmarshal(dAtA []byte) error { } return nil } +func (m *CustomResourceValidation) 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: CustomResourceValidation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomResourceValidation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OpenAPIV3Schema", 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 > l { + return io.ErrUnexpectedEOF + } + if m.OpenAPIV3Schema == nil { + m.OpenAPIV3Schema = &JSONSchemaProps{} + } + if err := m.OpenAPIV3Schema.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 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalDocumentation) 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: ExternalDocumentation: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalDocumentation: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", 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 > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field URL", 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 > l { + return io.ErrUnexpectedEOF + } + m.URL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JSON) 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: JSON: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JSON: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...) + if m.Raw == nil { + m.Raw = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JSONSchemaProps) 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: JSONSchemaProps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JSONSchemaProps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", 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 > l { + return io.ErrUnexpectedEOF + } + m.ID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Schema", 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 > l { + return io.ErrUnexpectedEOF + } + m.Schema = JSONSchemaURL(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ref", 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 > l { + return io.ErrUnexpectedEOF + } + s := string(dAtA[iNdEx:postIndex]) + m.Ref = &s + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", 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 > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", 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 > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Format", 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 > l { + return io.ErrUnexpectedEOF + } + m.Format = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", 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 > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Default", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Default == nil { + m.Default = &JSON{} + } + if err := m.Default.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Maximum", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(dAtA[iNdEx-8]) + v |= uint64(dAtA[iNdEx-7]) << 8 + v |= uint64(dAtA[iNdEx-6]) << 16 + v |= uint64(dAtA[iNdEx-5]) << 24 + v |= uint64(dAtA[iNdEx-4]) << 32 + v |= uint64(dAtA[iNdEx-3]) << 40 + v |= uint64(dAtA[iNdEx-2]) << 48 + v |= uint64(dAtA[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Maximum = &v2 + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExclusiveMaximum", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ExclusiveMaximum = bool(v != 0) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Minimum", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(dAtA[iNdEx-8]) + v |= uint64(dAtA[iNdEx-7]) << 8 + v |= uint64(dAtA[iNdEx-6]) << 16 + v |= uint64(dAtA[iNdEx-5]) << 24 + v |= uint64(dAtA[iNdEx-4]) << 32 + v |= uint64(dAtA[iNdEx-3]) << 40 + v |= uint64(dAtA[iNdEx-2]) << 48 + v |= uint64(dAtA[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Minimum = &v2 + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExclusiveMinimum", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.ExclusiveMinimum = bool(v != 0) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxLength", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MaxLength = &v + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinLength", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MinLength = &v + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pattern", 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 > l { + return io.ErrUnexpectedEOF + } + m.Pattern = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxItems", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MaxItems = &v + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinItems", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MinItems = &v + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UniqueItems", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.UniqueItems = bool(v != 0) + case 19: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field MultipleOf", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(dAtA[iNdEx-8]) + v |= uint64(dAtA[iNdEx-7]) << 8 + v |= uint64(dAtA[iNdEx-6]) << 16 + v |= uint64(dAtA[iNdEx-5]) << 24 + v |= uint64(dAtA[iNdEx-4]) << 32 + v |= uint64(dAtA[iNdEx-3]) << 40 + v |= uint64(dAtA[iNdEx-2]) << 48 + v |= uint64(dAtA[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.MultipleOf = &v2 + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Enum", 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 > l { + return io.ErrUnexpectedEOF + } + m.Enum = append(m.Enum, JSON{}) + if err := m.Enum[len(m.Enum)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxProperties", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MaxProperties = &v + case 22: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinProperties", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MinProperties = &v + case 23: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Required", 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 > l { + return io.ErrUnexpectedEOF + } + m.Required = append(m.Required, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 24: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Items == nil { + m.Items = &JSONSchemaPropsOrArray{} + } + if err := m.Items.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 25: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AllOf", 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 > l { + return io.ErrUnexpectedEOF + } + m.AllOf = append(m.AllOf, JSONSchemaProps{}) + if err := m.AllOf[len(m.AllOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OneOf", 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 > l { + return io.ErrUnexpectedEOF + } + m.OneOf = append(m.OneOf, JSONSchemaProps{}) + if err := m.OneOf[len(m.OneOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 27: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AnyOf", 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 > l { + return io.ErrUnexpectedEOF + } + m.AnyOf = append(m.AnyOf, JSONSchemaProps{}) + if err := m.AnyOf[len(m.AnyOf)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 28: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Not", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Not == nil { + m.Not = &JSONSchemaProps{} + } + if err := m.Not.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 29: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Properties", 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 > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + if m.Properties == nil { + m.Properties = make(map[string]JSONSchemaProps) + } + if iNdEx < postIndex { + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &JSONSchemaProps{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + m.Properties[mapkey] = *mapvalue + } else { + var mapvalue JSONSchemaProps + m.Properties[mapkey] = mapvalue + } + iNdEx = postIndex + case 30: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AdditionalProperties", 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 > l { + return io.ErrUnexpectedEOF + } + if m.AdditionalProperties == nil { + m.AdditionalProperties = &JSONSchemaPropsOrBool{} + } + if err := m.AdditionalProperties.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 31: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PatternProperties", 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 > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + if m.PatternProperties == nil { + m.PatternProperties = make(map[string]JSONSchemaProps) + } + if iNdEx < postIndex { + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &JSONSchemaProps{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + m.PatternProperties[mapkey] = *mapvalue + } else { + var mapvalue JSONSchemaProps + m.PatternProperties[mapkey] = mapvalue + } + iNdEx = postIndex + case 32: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Dependencies", 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 > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + if m.Dependencies == nil { + m.Dependencies = make(JSONSchemaDependencies) + } + if iNdEx < postIndex { + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &JSONSchemaPropsOrStringArray{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + m.Dependencies[mapkey] = *mapvalue + } else { + var mapvalue JSONSchemaPropsOrStringArray + m.Dependencies[mapkey] = mapvalue + } + iNdEx = postIndex + case 33: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AdditionalItems", 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 > l { + return io.ErrUnexpectedEOF + } + if m.AdditionalItems == nil { + m.AdditionalItems = &JSONSchemaPropsOrBool{} + } + if err := m.AdditionalItems.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Definitions", 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 > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + if m.Definitions == nil { + m.Definitions = make(JSONSchemaDefinitions) + } + if iNdEx < postIndex { + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthGenerated + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &JSONSchemaProps{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + m.Definitions[mapkey] = *mapvalue + } else { + var mapvalue JSONSchemaProps + m.Definitions[mapkey] = mapvalue + } + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExternalDocs", 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 > l { + return io.ErrUnexpectedEOF + } + if m.ExternalDocs == nil { + m.ExternalDocs = &ExternalDocumentation{} + } + if err := m.ExternalDocs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Example", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Example == nil { + m.Example = &JSON{} + } + if err := m.Example.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 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JSONSchemaPropsOrArray) 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: JSONSchemaPropsOrArray: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JSONSchemaPropsOrArray: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Schema", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Schema == nil { + m.Schema = &JSONSchemaProps{} + } + if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JSONSchemas", 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 > l { + return io.ErrUnexpectedEOF + } + m.JSONSchemas = append(m.JSONSchemas, JSONSchemaProps{}) + if err := m.JSONSchemas[len(m.JSONSchemas)-1].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 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JSONSchemaPropsOrBool) 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: JSONSchemaPropsOrBool: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JSONSchemaPropsOrBool: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Allows", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Allows = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Schema", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Schema == nil { + m.Schema = &JSONSchemaProps{} + } + if err := m.Schema.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 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *JSONSchemaPropsOrStringArray) 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: JSONSchemaPropsOrStringArray: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JSONSchemaPropsOrStringArray: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Schema", 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 > l { + return io.ErrUnexpectedEOF + } + if m.Schema == nil { + m.Schema = &JSONSchemaProps{} + } + if err := m.Schema.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Property", 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 > l { + return io.ErrUnexpectedEOF + } + m.Property = append(m.Property, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipGenerated(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 @@ -1588,58 +4660,125 @@ func init() { } var fileDescriptorGenerated = []byte{ - // 845 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcf, 0x8b, 0x23, 0x45, - 0x14, 0x4e, 0xe7, 0xc7, 0xcc, 0x58, 0xeb, 0xb8, 0x52, 0x20, 0x34, 0x83, 0x76, 0x66, 0x23, 0xca, - 0x2a, 0x4e, 0xb7, 0xb3, 0xae, 0xa2, 0x07, 0x0f, 0x66, 0x05, 0x59, 0xdc, 0x55, 0xa9, 0x59, 0x14, - 0x74, 0xc5, 0xad, 0x74, 0xde, 0x74, 0xca, 0xa4, 0xab, 0x9a, 0xaa, 0xea, 0xe0, 0x80, 0x82, 0x22, - 0xde, 0x3d, 0x78, 0xf1, 0x3f, 0xf0, 0x4f, 0x99, 0xe3, 0x82, 0x97, 0x3d, 0x05, 0x27, 0xfe, 0x0b, - 0x7a, 0xc9, 0x49, 0xaa, 0xba, 0x52, 0x49, 0x8c, 0x71, 0x07, 0x24, 0xde, 0xa6, 0xdf, 0x8f, 0xef, - 0xfb, 0xde, 0xf7, 0x5e, 0x6a, 0xd0, 0xe9, 0xf0, 0x4d, 0x15, 0x33, 0x91, 0x0c, 0xcb, 0x1e, 0x48, - 0x0e, 0x1a, 0x54, 0x32, 0x06, 0xde, 0x17, 0x32, 0x71, 0x09, 0x5a, 0x30, 0xf8, 0x4a, 0x03, 0x57, - 0x4c, 0x70, 0x75, 0x44, 0x0b, 0xa6, 0x40, 0x8e, 0x41, 0x26, 0xc5, 0x30, 0x33, 0x39, 0xb5, 0x5a, - 0x90, 0x8c, 0x8f, 0x7b, 0xa0, 0xe9, 0x71, 0x92, 0x01, 0x07, 0x49, 0x35, 0xf4, 0xe3, 0x42, 0x0a, - 0x2d, 0xf0, 0xdb, 0x15, 0x5c, 0xbc, 0x52, 0xfd, 0x85, 0x87, 0x8b, 0x8b, 0x61, 0x66, 0x72, 0x6a, - 0xb5, 0x20, 0x76, 0x70, 0x07, 0x47, 0x19, 0xd3, 0x83, 0xb2, 0x17, 0xa7, 0x22, 0x4f, 0x32, 0x91, - 0x89, 0xc4, 0xa2, 0xf6, 0xca, 0x53, 0xfb, 0x65, 0x3f, 0xec, 0x5f, 0x15, 0xdb, 0xc1, 0xcd, 0x85, - 0xf8, 0x9c, 0xa6, 0x03, 0xc6, 0x41, 0x9e, 0x2d, 0x14, 0xe7, 0xa0, 0x69, 0x32, 0x5e, 0xd3, 0x78, - 0x90, 0x6c, 0xea, 0x92, 0x25, 0xd7, 0x2c, 0x87, 0xb5, 0x86, 0x37, 0x1e, 0xd7, 0xa0, 0xd2, 0x01, - 0xe4, 0x74, 0xad, 0xef, 0xb5, 0x4d, 0x7d, 0xa5, 0x66, 0xa3, 0x84, 0x71, 0xad, 0xb4, 0xfc, 0x7b, - 0x53, 0xe7, 0xfb, 0x06, 0x0a, 0x6f, 0x95, 0x4a, 0x8b, 0x9c, 0x80, 0x12, 0xa5, 0x4c, 0xe1, 0x5d, - 0x38, 0x65, 0x9c, 0x69, 0x26, 0x38, 0x7e, 0x80, 0xf6, 0xcc, 0x54, 0x7d, 0xaa, 0x69, 0x18, 0x1c, - 0x06, 0xd7, 0xaf, 0xdc, 0x78, 0x35, 0x5e, 0x38, 0xee, 0x49, 0x16, 0x36, 0x9b, 0xea, 0x78, 0x7c, - 0x1c, 0x7f, 0xd8, 0xfb, 0x12, 0x52, 0x7d, 0x17, 0x34, 0xed, 0xe2, 0xf3, 0x49, 0xbb, 0x36, 0x9d, - 0xb4, 0xd1, 0x22, 0x46, 0x3c, 0x2a, 0xfe, 0x06, 0x35, 0x55, 0x01, 0x69, 0x58, 0xb7, 0xe8, 0x9f, - 0xc5, 0xff, 0x69, 0x9f, 0xf1, 0xa6, 0x41, 0x4e, 0x0a, 0x48, 0xbb, 0x4f, 0x3a, 0x21, 0x4d, 0xf3, - 0x45, 0x2c, 0x2d, 0xfe, 0x21, 0x40, 0x3b, 0x4a, 0x53, 0x5d, 0xaa, 0xb0, 0x61, 0x15, 0x7c, 0xbe, - 0x2d, 0x05, 0x96, 0xa4, 0xfb, 0x94, 0xd3, 0xb0, 0x53, 0x7d, 0x13, 0x47, 0xde, 0xf9, 0xa3, 0x8e, - 0xae, 0x6d, 0x6a, 0xbd, 0x25, 0x78, 0xbf, 0x5a, 0xc7, 0x6d, 0xd4, 0xd4, 0x67, 0x05, 0xd8, 0x55, - 0x3c, 0xd1, 0x7d, 0x7d, 0x3e, 0xcf, 0xbd, 0xb3, 0x02, 0x66, 0x93, 0xf6, 0x0b, 0x8f, 0x05, 0x30, - 0x85, 0xc4, 0x42, 0xe0, 0xb7, 0xfc, 0xdc, 0x75, 0x0b, 0x76, 0x6d, 0x55, 0xd8, 0x6c, 0xd2, 0xbe, - 0xea, 0xdb, 0x56, 0xb5, 0xe2, 0x31, 0xc2, 0x23, 0xaa, 0xf4, 0x3d, 0x49, 0xb9, 0xaa, 0x60, 0x59, - 0x0e, 0xce, 0xbe, 0x97, 0x2f, 0x77, 0x1e, 0xa6, 0xa3, 0x7b, 0xe0, 0x28, 0xf1, 0x9d, 0x35, 0x34, - 0xf2, 0x0f, 0x0c, 0xf8, 0x45, 0xb4, 0x23, 0x81, 0x2a, 0xc1, 0xc3, 0xa6, 0x95, 0xec, 0xbd, 0x24, - 0x36, 0x4a, 0x5c, 0x16, 0xbf, 0x84, 0x76, 0x73, 0x50, 0x8a, 0x66, 0x10, 0xb6, 0x6c, 0xe1, 0x55, - 0x57, 0xb8, 0x7b, 0xb7, 0x0a, 0x93, 0x79, 0xbe, 0x33, 0x0b, 0xd0, 0xb3, 0x9b, 0x5c, 0xbb, 0xc3, - 0x94, 0xc6, 0xf7, 0xd7, 0x7e, 0x00, 0xf1, 0xe5, 0x26, 0x34, 0xdd, 0xf6, 0xfc, 0x9f, 0x76, 0xe4, - 0x7b, 0xf3, 0xc8, 0xd2, 0xf1, 0x7f, 0x8d, 0x5a, 0x4c, 0x43, 0x6e, 0x76, 0xd0, 0xb8, 0x7e, 0xe5, - 0xc6, 0x27, 0x5b, 0xba, 0xbd, 0xee, 0xbe, 0xd3, 0xd0, 0xba, 0x6d, 0xd8, 0x48, 0x45, 0xda, 0xf9, - 0x33, 0x40, 0xcf, 0x6d, 0x6a, 0xf9, 0x80, 0xe6, 0xa0, 0x8c, 0xe3, 0xc5, 0xa8, 0x94, 0x74, 0xe4, - 0x2e, 0xce, 0x3b, 0xfe, 0x91, 0x8d, 0x12, 0x97, 0xc5, 0xaf, 0xa0, 0x3d, 0xc5, 0x78, 0x56, 0x8e, - 0xa8, 0x74, 0xe7, 0xe4, 0xa7, 0x3e, 0x71, 0x71, 0xe2, 0x2b, 0x70, 0x8c, 0x90, 0x1a, 0x08, 0xa9, - 0x2d, 0x47, 0xd8, 0x38, 0x6c, 0x18, 0x64, 0xf3, 0x40, 0x9c, 0xf8, 0x28, 0x59, 0xaa, 0xc0, 0x87, - 0xa8, 0x39, 0x64, 0xbc, 0xef, 0xb6, 0xee, 0x7f, 0xc5, 0xef, 0x33, 0xde, 0x27, 0x36, 0x63, 0xf8, - 0x47, 0x4c, 0x69, 0x13, 0x71, 0x2b, 0x5f, 0x71, 0xdd, 0x56, 0xfa, 0x8a, 0xce, 0x2f, 0xf5, 0xcd, - 0x4b, 0x37, 0x4f, 0x03, 0x7e, 0x1e, 0xb5, 0x32, 0x29, 0xca, 0xc2, 0x4d, 0xed, 0xdd, 0x7b, 0xcf, - 0x04, 0x49, 0x95, 0x33, 0x57, 0x36, 0x06, 0x69, 0x16, 0xe0, 0x46, 0xf6, 0x57, 0xf6, 0x71, 0x15, - 0x26, 0xf3, 0x3c, 0xfe, 0x2e, 0x40, 0x2d, 0xee, 0x86, 0x35, 0x27, 0x74, 0x7f, 0x4b, 0x7b, 0xb6, - 0x76, 0x2d, 0xe4, 0x56, 0x4e, 0x56, 0xcc, 0xf8, 0x26, 0x6a, 0xa9, 0x54, 0x14, 0xe0, 0x5c, 0x8c, - 0xe6, 0x45, 0x27, 0x26, 0x38, 0x9b, 0xb4, 0xf7, 0xe7, 0x70, 0x36, 0x40, 0xaa, 0xe2, 0xce, 0xaf, - 0x75, 0x14, 0xfd, 0xfb, 0x8b, 0x86, 0x7f, 0x0a, 0x10, 0x4a, 0xe7, 0x2f, 0x85, 0x0a, 0x03, 0x7b, - 0xc9, 0x0f, 0xb6, 0x34, 0xa1, 0x7f, 0x92, 0x16, 0xff, 0x55, 0x7c, 0x48, 0x91, 0x25, 0x1d, 0xf8, - 0xe7, 0x00, 0xed, 0xd3, 0x34, 0x85, 0x42, 0x43, 0xbf, 0x3a, 0xb4, 0xfa, 0xff, 0xe0, 0xfd, 0x33, - 0x4e, 0xd5, 0xfe, 0x3b, 0xcb, 0xd4, 0x64, 0x55, 0x49, 0xf7, 0xe8, 0xfc, 0x22, 0xaa, 0x3d, 0xbc, - 0x88, 0x6a, 0x8f, 0x2e, 0xa2, 0xda, 0xb7, 0xd3, 0x28, 0x38, 0x9f, 0x46, 0xc1, 0xc3, 0x69, 0x14, - 0x3c, 0x9a, 0x46, 0xc1, 0x6f, 0xd3, 0x28, 0xf8, 0xf1, 0xf7, 0xa8, 0xf6, 0xe9, 0xae, 0xa3, 0xfc, - 0x2b, 0x00, 0x00, 0xff, 0xff, 0x3e, 0xed, 0x57, 0x73, 0x4c, 0x09, 0x00, 0x00, + // 1917 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xdb, 0x6f, 0x5b, 0x49, + 0x19, 0xcf, 0xd8, 0xb9, 0x4e, 0x92, 0x4d, 0x32, 0x6d, 0xca, 0x69, 0x68, 0xed, 0xd4, 0xcb, 0xae, + 0x02, 0x6c, 0x6d, 0xba, 0x17, 0x76, 0x41, 0xe2, 0x21, 0x6e, 0x02, 0x2a, 0x34, 0x4d, 0x35, 0x69, + 0x8b, 0xc4, 0x2e, 0xec, 0x4e, 0x7c, 0xc6, 0xce, 0x34, 0xe7, 0xcc, 0x39, 0x3d, 0x33, 0xc7, 0x8d, + 0x25, 0x90, 0x40, 0x68, 0x85, 0x84, 0x04, 0x42, 0xd0, 0x17, 0x24, 0x9e, 0x78, 0x44, 0x08, 0x24, + 0xe0, 0x91, 0x3f, 0xa0, 0x8f, 0x2b, 0xf1, 0xb2, 0x4f, 0x16, 0x35, 0xff, 0x02, 0xbc, 0xe4, 0x09, + 0xcd, 0xe5, 0xdc, 0xec, 0x64, 0xb7, 0xd2, 0xda, 0xdb, 0x37, 0x9f, 0xef, 0xf6, 0xfb, 0xcd, 0x37, + 0xdf, 0x7c, 0xf3, 0x8d, 0x61, 0xfb, 0xf8, 0x1d, 0x51, 0x67, 0x41, 0xe3, 0x38, 0x3e, 0xa4, 0x11, + 0xa7, 0x92, 0x8a, 0x46, 0x97, 0x72, 0x37, 0x88, 0x1a, 0x56, 0x41, 0x42, 0x46, 0x4f, 0x24, 0xe5, + 0x82, 0x05, 0x5c, 0x5c, 0x27, 0x21, 0x13, 0x34, 0xea, 0xd2, 0xa8, 0x11, 0x1e, 0x77, 0x94, 0x4e, + 0x14, 0x0d, 0x1a, 0xdd, 0x1b, 0x87, 0x54, 0x92, 0x1b, 0x8d, 0x0e, 0xe5, 0x34, 0x22, 0x92, 0xba, + 0xf5, 0x30, 0x0a, 0x64, 0x80, 0xbe, 0x65, 0xc2, 0xd5, 0x0b, 0xd6, 0xef, 0xa7, 0xe1, 0xea, 0xe1, + 0x71, 0x47, 0xe9, 0x44, 0xd1, 0xa0, 0x6e, 0xc3, 0x6d, 0x5c, 0xef, 0x30, 0x79, 0x14, 0x1f, 0xd6, + 0x5b, 0x81, 0xdf, 0xe8, 0x04, 0x9d, 0xa0, 0xa1, 0xa3, 0x1e, 0xc6, 0x6d, 0xfd, 0xa5, 0x3f, 0xf4, + 0x2f, 0x83, 0xb6, 0xf1, 0x66, 0x46, 0xde, 0x27, 0xad, 0x23, 0xc6, 0x69, 0xd4, 0xcb, 0x18, 0xfb, + 0x54, 0x92, 0x46, 0x77, 0x84, 0xe3, 0x46, 0xe3, 0x3c, 0xaf, 0x28, 0xe6, 0x92, 0xf9, 0x74, 0xc4, + 0xe1, 0xeb, 0x9f, 0xe6, 0x20, 0x5a, 0x47, 0xd4, 0x27, 0x23, 0x7e, 0x6f, 0x9c, 0xe7, 0x17, 0x4b, + 0xe6, 0x35, 0x18, 0x97, 0x42, 0x46, 0xc3, 0x4e, 0xb5, 0x9f, 0x97, 0xa1, 0x73, 0x33, 0x16, 0x32, + 0xf0, 0x31, 0x15, 0x41, 0x1c, 0xb5, 0xe8, 0x0e, 0x6d, 0x33, 0xce, 0x24, 0x0b, 0x38, 0xfa, 0x00, + 0xce, 0xab, 0x55, 0xb9, 0x44, 0x12, 0x07, 0x6c, 0x82, 0xad, 0xc5, 0xd7, 0xbf, 0x56, 0xcf, 0x32, + 0x9e, 0x82, 0x64, 0x69, 0x56, 0xd6, 0xf5, 0xee, 0x8d, 0xfa, 0xfe, 0xe1, 0x43, 0xda, 0x92, 0x7b, + 0x54, 0x92, 0x26, 0x7a, 0xda, 0xaf, 0x4e, 0x0d, 0xfa, 0x55, 0x98, 0xc9, 0x70, 0x1a, 0x15, 0xfd, + 0x04, 0x4e, 0x8b, 0x90, 0xb6, 0x9c, 0x92, 0x8e, 0xfe, 0x6e, 0xfd, 0x33, 0xed, 0x67, 0xfd, 0xbc, + 0x85, 0x1c, 0x84, 0xb4, 0xd5, 0x5c, 0xb2, 0x44, 0xa6, 0xd5, 0x17, 0xd6, 0xb0, 0xe8, 0x43, 0x00, + 0x67, 0x85, 0x24, 0x32, 0x16, 0x4e, 0x59, 0x33, 0xf8, 0xe1, 0xa4, 0x18, 0x68, 0x90, 0xe6, 0x4b, + 0x96, 0xc3, 0xac, 0xf9, 0xc6, 0x16, 0xbc, 0xf6, 0xdf, 0x12, 0xbc, 0x76, 0x9e, 0xeb, 0xcd, 0x80, + 0xbb, 0x66, 0x3b, 0x6e, 0xc1, 0x69, 0xd9, 0x0b, 0xa9, 0xde, 0x8a, 0x85, 0xe6, 0x5b, 0xc9, 0x7a, + 0xee, 0xf5, 0x42, 0x7a, 0xda, 0xaf, 0xbe, 0xf2, 0xa9, 0x01, 0x94, 0x21, 0xd6, 0x21, 0xd0, 0x37, + 0xd2, 0x75, 0x97, 0x74, 0xb0, 0x6b, 0x45, 0x62, 0xa7, 0xfd, 0xea, 0x4a, 0xea, 0x56, 0xe4, 0x8a, + 0xba, 0x10, 0x79, 0x44, 0xc8, 0x7b, 0x11, 0xe1, 0xc2, 0x84, 0x65, 0x3e, 0xb5, 0xe9, 0xfb, 0xca, + 0xf3, 0x95, 0x87, 0xf2, 0x68, 0x6e, 0x58, 0x48, 0x74, 0x7b, 0x24, 0x1a, 0x3e, 0x03, 0x01, 0xbd, + 0x0a, 0x67, 0x23, 0x4a, 0x44, 0xc0, 0x9d, 0x69, 0x4d, 0x39, 0xcd, 0x25, 0xd6, 0x52, 0x6c, 0xb5, + 0xe8, 0xcb, 0x70, 0xce, 0xa7, 0x42, 0x90, 0x0e, 0x75, 0x66, 0xb4, 0xe1, 0x8a, 0x35, 0x9c, 0xdb, + 0x33, 0x62, 0x9c, 0xe8, 0x6b, 0xa7, 0x00, 0x5e, 0x39, 0x2f, 0x6b, 0xb7, 0x99, 0x90, 0xe8, 0xbd, + 0x91, 0x03, 0x50, 0x7f, 0xbe, 0x15, 0x2a, 0x6f, 0x5d, 0xfe, 0xab, 0x16, 0x7c, 0x3e, 0x91, 0xe4, + 0x8a, 0xff, 0xc7, 0x70, 0x86, 0x49, 0xea, 0xab, 0x3d, 0x28, 0x6f, 0x2d, 0xbe, 0xfe, 0xfd, 0x09, + 0xd5, 0x5e, 0x73, 0xd9, 0x72, 0x98, 0xb9, 0xa5, 0xd0, 0xb0, 0x01, 0xad, 0xfd, 0x0f, 0xc0, 0xab, + 0xe7, 0xb9, 0xdc, 0x21, 0x3e, 0x15, 0x2a, 0xe3, 0xa1, 0x17, 0x47, 0xc4, 0xb3, 0x15, 0x97, 0x66, + 0xfc, 0xae, 0x96, 0x62, 0xab, 0x45, 0xaf, 0xc1, 0x79, 0xc1, 0x78, 0x27, 0xf6, 0x48, 0x64, 0xcb, + 0x29, 0x5d, 0xf5, 0x81, 0x95, 0xe3, 0xd4, 0x02, 0xd5, 0x21, 0x14, 0x47, 0x41, 0x24, 0x35, 0x86, + 0x53, 0xde, 0x2c, 0xab, 0xc8, 0xaa, 0x41, 0x1c, 0xa4, 0x52, 0x9c, 0xb3, 0x40, 0x9b, 0x70, 0xfa, + 0x98, 0x71, 0xd7, 0xee, 0x7a, 0x7a, 0x8a, 0xbf, 0xc7, 0xb8, 0x8b, 0xb5, 0x46, 0xe1, 0x7b, 0x4c, + 0x48, 0x25, 0xb1, 0x5b, 0x5e, 0xc8, 0xba, 0xb6, 0x4c, 0x2d, 0x6a, 0x7f, 0x2b, 0x9f, 0xbf, 0xe9, + 0xaa, 0x35, 0xa0, 0x97, 0xe1, 0x4c, 0x27, 0x0a, 0xe2, 0xd0, 0xae, 0x3a, 0xcd, 0xde, 0x77, 0x94, + 0x10, 0x1b, 0x9d, 0xaa, 0xb2, 0x2e, 0x8d, 0xd4, 0x06, 0xd8, 0x25, 0xa7, 0x55, 0xf6, 0xc0, 0x88, + 0x71, 0xa2, 0x47, 0x3f, 0x03, 0x70, 0x86, 0xdb, 0xc5, 0xaa, 0x12, 0x7a, 0x6f, 0x42, 0xfb, 0xac, + 0xd3, 0x95, 0xd1, 0x35, 0x99, 0x34, 0xc8, 0xe8, 0x4d, 0x38, 0x23, 0x5a, 0x41, 0x48, 0x6d, 0x16, + 0x2b, 0x89, 0xd1, 0x81, 0x12, 0x9e, 0xf6, 0xab, 0xcb, 0x49, 0x38, 0x2d, 0xc0, 0xc6, 0x18, 0xfd, + 0x02, 0x40, 0xd8, 0x25, 0x1e, 0x73, 0x89, 0x8a, 0xaf, 0x73, 0x3b, 0xee, 0x32, 0x7d, 0x90, 0x86, + 0x37, 0x45, 0x90, 0x7d, 0xe3, 0x1c, 0x74, 0xed, 0x5f, 0x25, 0x58, 0xf9, 0xe4, 0xde, 0x8a, 0x9e, + 0x00, 0x08, 0x5b, 0x49, 0xcf, 0x12, 0x0e, 0xd0, 0x67, 0xea, 0x83, 0x09, 0xe5, 0x3a, 0x6d, 0x8e, + 0xd9, 0xfd, 0x96, 0x8a, 0x04, 0xce, 0xf1, 0x40, 0xbf, 0x07, 0x70, 0x99, 0xb4, 0x5a, 0x34, 0x94, + 0xd4, 0x35, 0x25, 0x5f, 0xfa, 0x1c, 0xaa, 0x60, 0xdd, 0xb2, 0x5a, 0xde, 0xce, 0x43, 0xe3, 0x22, + 0x93, 0xda, 0x9f, 0xc0, 0xf0, 0xe5, 0x9f, 0xa5, 0x1f, 0xfd, 0x0a, 0xc0, 0x95, 0x20, 0xa4, 0x7c, + 0xfb, 0xee, 0xad, 0x07, 0x6f, 0x1c, 0xe8, 0x91, 0xc3, 0xf6, 0xc0, 0x3b, 0x9f, 0x91, 0xfa, 0x77, + 0x0f, 0xf6, 0xef, 0x98, 0x80, 0x77, 0xa3, 0x20, 0x14, 0xcd, 0x0b, 0x83, 0x7e, 0x75, 0x65, 0xbf, + 0x08, 0x85, 0x87, 0xb1, 0x6b, 0x3e, 0x5c, 0xdf, 0x3d, 0x91, 0x34, 0xe2, 0xc4, 0xdb, 0x09, 0x5a, + 0xb1, 0x4f, 0xb9, 0x34, 0x44, 0xdf, 0x82, 0x8b, 0x2e, 0x15, 0xad, 0x88, 0x85, 0xba, 0x4a, 0xcd, + 0xa9, 0xbd, 0x60, 0x13, 0xb0, 0xb8, 0x93, 0xa9, 0x70, 0xde, 0x0e, 0x5d, 0x85, 0xe5, 0x38, 0xf2, + 0xec, 0xe9, 0x5d, 0xb4, 0xe6, 0xe5, 0xfb, 0xf8, 0x36, 0x56, 0xf2, 0xda, 0x35, 0x38, 0xad, 0x78, + 0xa2, 0xcb, 0xb0, 0x1c, 0x91, 0xc7, 0x3a, 0xea, 0x52, 0x73, 0x4e, 0x99, 0x60, 0xf2, 0x18, 0x2b, + 0x59, 0xed, 0xcf, 0x57, 0xe0, 0xca, 0xd0, 0x5a, 0xd0, 0x06, 0x2c, 0x31, 0xd7, 0x72, 0x80, 0x36, + 0x68, 0xe9, 0xd6, 0x0e, 0x2e, 0x31, 0x17, 0xbd, 0x0d, 0x67, 0xcd, 0xe8, 0x66, 0x41, 0xab, 0xe9, + 0xa5, 0xab, 0xa5, 0xea, 0x18, 0x66, 0xe1, 0x14, 0x11, 0x6b, 0xae, 0x39, 0xd0, 0xb6, 0x6e, 0x1f, + 0x0b, 0x96, 0x03, 0x6d, 0x63, 0x25, 0x1b, 0x5e, 0xfc, 0xf4, 0x73, 0x2e, 0x7e, 0xd3, 0x8e, 0x12, + 0x33, 0xc5, 0xa6, 0x9a, 0x9b, 0x10, 0x5e, 0x85, 0xb3, 0xed, 0x20, 0xf2, 0x89, 0x74, 0x66, 0x8b, + 0xcd, 0xff, 0xdb, 0x5a, 0x8a, 0xad, 0x56, 0x75, 0x4b, 0xc9, 0xa4, 0x47, 0x9d, 0xb9, 0x62, 0xb7, + 0xbc, 0xa7, 0x84, 0xd8, 0xe8, 0xd0, 0x43, 0x38, 0xe7, 0xd2, 0x36, 0x89, 0x3d, 0xe9, 0xcc, 0xeb, + 0x12, 0xba, 0x39, 0x86, 0x12, 0x6a, 0x2e, 0xaa, 0x76, 0xbb, 0x63, 0xe2, 0xe2, 0x04, 0x00, 0xbd, + 0x02, 0xe7, 0x7c, 0x72, 0xc2, 0xfc, 0xd8, 0x77, 0x16, 0x36, 0xc1, 0x16, 0x30, 0x66, 0x7b, 0x46, + 0x84, 0x13, 0x1d, 0xda, 0x81, 0xab, 0xf4, 0xa4, 0xe5, 0xc5, 0x82, 0x75, 0xa9, 0x55, 0x3a, 0x70, + 0x13, 0x6c, 0xcd, 0x37, 0x1d, 0xbb, 0x84, 0xd5, 0xdd, 0x21, 0x3d, 0x1e, 0xf1, 0xd0, 0x60, 0x8c, + 0x6b, 0xe7, 0xc5, 0x1c, 0x98, 0x11, 0xe1, 0x44, 0x57, 0x04, 0xb3, 0xf6, 0x4b, 0xe7, 0x81, 0x59, + 0xe7, 0x11, 0x0f, 0xf4, 0x55, 0xb8, 0xe0, 0x93, 0x93, 0xdb, 0x94, 0x77, 0xe4, 0x91, 0xb3, 0xbc, + 0x09, 0xb6, 0xca, 0xcd, 0xe5, 0x41, 0xbf, 0xba, 0xb0, 0x97, 0x08, 0x71, 0xa6, 0xd7, 0xc6, 0x8c, + 0x5b, 0xe3, 0x97, 0x72, 0xc6, 0x89, 0x10, 0x67, 0x7a, 0x75, 0x9b, 0x85, 0x44, 0xaa, 0xc3, 0xe5, + 0xac, 0x14, 0x6f, 0xb3, 0xbb, 0x46, 0x8c, 0x13, 0x3d, 0xda, 0x82, 0xf3, 0x3e, 0x39, 0xd1, 0x93, + 0x84, 0xb3, 0xaa, 0xc3, 0x2e, 0xa9, 0x8b, 0x76, 0xcf, 0xca, 0x70, 0xaa, 0xd5, 0x96, 0x8c, 0x1b, + 0xcb, 0xb5, 0x9c, 0xa5, 0x95, 0xe1, 0x54, 0xab, 0x8a, 0x38, 0xe6, 0xec, 0x51, 0x4c, 0x8d, 0x31, + 0xd2, 0x99, 0x49, 0x8b, 0xf8, 0x7e, 0xa6, 0xc2, 0x79, 0x3b, 0x35, 0x49, 0xf8, 0xb1, 0x27, 0x59, + 0xe8, 0xd1, 0xfd, 0xb6, 0x73, 0x41, 0xe7, 0x5f, 0x5f, 0x22, 0x7b, 0xa9, 0x14, 0xe7, 0x2c, 0x10, + 0x85, 0xd3, 0x94, 0xc7, 0xbe, 0x73, 0x51, 0x5f, 0x0d, 0x63, 0x29, 0xc1, 0xf4, 0xe4, 0xec, 0xf2, + 0xd8, 0xc7, 0x3a, 0x3c, 0x7a, 0x1b, 0x2e, 0xfb, 0xe4, 0x44, 0xb5, 0x03, 0x1a, 0x49, 0x46, 0x85, + 0xb3, 0xae, 0x17, 0xbf, 0xa6, 0xda, 0xf1, 0x5e, 0x5e, 0x81, 0x8b, 0x76, 0xda, 0x91, 0xf1, 0x9c, + 0xe3, 0xa5, 0x9c, 0x63, 0x5e, 0x81, 0x8b, 0x76, 0x2a, 0xd3, 0x11, 0x7d, 0x14, 0xb3, 0x88, 0xba, + 0xce, 0x17, 0xf4, 0x40, 0xa5, 0x33, 0x8d, 0xad, 0x0c, 0xa7, 0x5a, 0xd4, 0x4d, 0x46, 0x4e, 0x47, + 0x1f, 0xc3, 0xfb, 0xe3, 0xed, 0xe4, 0xfb, 0xd1, 0x76, 0x14, 0x91, 0x5e, 0x73, 0x61, 0x78, 0xd8, + 0x44, 0x02, 0xce, 0x10, 0xcf, 0xdb, 0x6f, 0x3b, 0x97, 0x75, 0xee, 0xc7, 0x7d, 0x83, 0xa4, 0x5d, + 0x67, 0x5b, 0x81, 0x60, 0x83, 0xa5, 0x40, 0x03, 0xae, 0x4a, 0x63, 0x63, 0xb2, 0xa0, 0xfb, 0x0a, + 0x04, 0x1b, 0x2c, 0xbd, 0x52, 0xde, 0xdb, 0x6f, 0x3b, 0x5f, 0x9c, 0xf0, 0x4a, 0x15, 0x08, 0x36, + 0x58, 0x88, 0xc1, 0x32, 0x0f, 0xa4, 0x73, 0x65, 0x22, 0xd7, 0xb3, 0xbe, 0x70, 0xee, 0x04, 0x12, + 0x2b, 0x0c, 0xf4, 0x5b, 0x00, 0x61, 0x98, 0x95, 0xe8, 0x55, 0xbd, 0xca, 0x1f, 0x8d, 0x17, 0xb2, + 0x9e, 0xd5, 0xf6, 0x2e, 0x97, 0x51, 0x2f, 0x1b, 0xb2, 0x72, 0x67, 0x20, 0xc7, 0x02, 0xfd, 0x11, + 0xc0, 0x8b, 0xc4, 0x35, 0x23, 0x17, 0xf1, 0x72, 0x27, 0xa8, 0xa2, 0x33, 0x72, 0x6f, 0xdc, 0x65, + 0xde, 0x0c, 0x02, 0xaf, 0xe9, 0x0c, 0xfa, 0xd5, 0x8b, 0xdb, 0x67, 0xa0, 0xe2, 0x33, 0xb9, 0xa0, + 0xbf, 0x00, 0xb8, 0x66, 0xbb, 0x68, 0x8e, 0x61, 0x55, 0x27, 0x90, 0x8e, 0x3b, 0x81, 0xc3, 0x38, + 0x26, 0x8f, 0x97, 0x6d, 0x1e, 0xd7, 0x46, 0xf4, 0x78, 0x94, 0x1a, 0xfa, 0x07, 0x80, 0x4b, 0x2e, + 0x0d, 0x29, 0x77, 0x29, 0x6f, 0x29, 0xae, 0x9b, 0x63, 0x99, 0xa9, 0x87, 0xb9, 0xee, 0xe4, 0x20, + 0x0c, 0xcd, 0xba, 0xa5, 0xb9, 0x94, 0x57, 0x9d, 0xf6, 0xab, 0x97, 0x32, 0xd7, 0xbc, 0x06, 0x17, + 0x58, 0xa2, 0xdf, 0x01, 0xb8, 0x92, 0x6d, 0x80, 0xb9, 0x52, 0xae, 0x4d, 0xb0, 0x0e, 0xf4, 0xf8, + 0xba, 0x5d, 0x04, 0xc4, 0xc3, 0x0c, 0xd0, 0x5f, 0x81, 0x9a, 0xd4, 0x92, 0x29, 0x5d, 0x38, 0x35, + 0x9d, 0xcb, 0xf7, 0xc7, 0x9e, 0xcb, 0x14, 0xc1, 0xa4, 0xf2, 0xb5, 0x6c, 0x14, 0x4c, 0x35, 0xa7, + 0xfd, 0xea, 0x7a, 0x3e, 0x93, 0xa9, 0x02, 0xe7, 0x19, 0xa2, 0x5f, 0x02, 0xb8, 0x44, 0xb3, 0x89, + 0x5b, 0x38, 0x2f, 0x8f, 0x25, 0x89, 0x67, 0x0e, 0xf1, 0xcd, 0x55, 0xb5, 0xdd, 0x39, 0x95, 0xc0, + 0x05, 0x6c, 0x35, 0x41, 0xd2, 0x13, 0xe2, 0x87, 0x1e, 0x75, 0xbe, 0x34, 0xe6, 0x09, 0x72, 0xd7, + 0xc4, 0xc5, 0x09, 0xc0, 0x86, 0x7a, 0xf9, 0x0c, 0x9d, 0x1c, 0xb4, 0x0a, 0xcb, 0xc7, 0xb4, 0x67, + 0x06, 0x7b, 0xac, 0x7e, 0x22, 0x17, 0xce, 0x74, 0x89, 0x17, 0x53, 0xfb, 0x9e, 0x1b, 0x73, 0xd7, + 0xc5, 0x26, 0xf8, 0x37, 0x4b, 0xef, 0x80, 0x8d, 0x27, 0x00, 0x5e, 0x3a, 0xfb, 0x40, 0xbf, 0x50, + 0x5a, 0x7f, 0x00, 0x70, 0x6d, 0xe4, 0xec, 0x9e, 0xc1, 0xe8, 0x51, 0x91, 0xd1, 0xbb, 0xe3, 0x3e, + 0x84, 0x07, 0x32, 0x62, 0xbc, 0xa3, 0x27, 0x8f, 0x3c, 0xbd, 0x5f, 0x03, 0xb8, 0x3a, 0x7c, 0x1c, + 0x5e, 0x64, 0xbe, 0x6a, 0x4f, 0x4a, 0xf0, 0xd2, 0xd9, 0x03, 0x13, 0x8a, 0xd2, 0x97, 0xe1, 0x64, + 0x5e, 0xd8, 0x30, 0x7b, 0x65, 0xa6, 0x8f, 0xca, 0x0f, 0x01, 0x5c, 0x7c, 0x98, 0xda, 0x25, 0x7f, + 0x42, 0x8e, 0xfd, 0x6d, 0x9f, 0xf4, 0x9f, 0x4c, 0x21, 0x70, 0x1e, 0xb7, 0xf6, 0x77, 0x00, 0xd7, + 0xcf, 0x6c, 0xac, 0xea, 0x09, 0x4a, 0x3c, 0x2f, 0x78, 0x2c, 0x74, 0x56, 0xe6, 0xb3, 0x27, 0xe8, + 0xb6, 0x96, 0x62, 0xab, 0xcd, 0x65, 0xaf, 0xf4, 0x79, 0x65, 0xaf, 0xf6, 0x4f, 0x00, 0xaf, 0x7c, + 0x52, 0x25, 0xbe, 0x90, 0x2d, 0xdd, 0x82, 0xf3, 0x76, 0x28, 0xea, 0xe9, 0xed, 0xb4, 0xef, 0x00, + 0xdb, 0x34, 0x7a, 0x38, 0xd5, 0x36, 0xaf, 0x3f, 0x7d, 0x56, 0x99, 0xfa, 0xe8, 0x59, 0x65, 0xea, + 0xe3, 0x67, 0x95, 0xa9, 0x9f, 0x0e, 0x2a, 0xe0, 0xe9, 0xa0, 0x02, 0x3e, 0x1a, 0x54, 0xc0, 0xc7, + 0x83, 0x0a, 0xf8, 0xf7, 0xa0, 0x02, 0x7e, 0xf3, 0x9f, 0xca, 0xd4, 0x0f, 0xe6, 0x2c, 0xf8, 0xff, + 0x03, 0x00, 0x00, 0xff, 0xff, 0x73, 0x96, 0x20, 0xc5, 0xd0, 0x1b, 0x00, 0x00, } diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto index d6e0ab94323..57a69e60c1b 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/generated.proto @@ -103,6 +103,11 @@ message CustomResourceDefinitionSpec { // Scope indicates whether this resource is cluster or namespace scoped. Default is namespaced optional string scope = 4; + + // Validation describes the validation methods for CustomResources + // This field is alpha-level and should only be sent to servers that enable the CustomResourceValidation feature. + // +optional + optional CustomResourceValidation validation = 5; } // CustomResourceDefinitionStatus indicates the state of the CustomResourceDefinition @@ -115,3 +120,120 @@ message CustomResourceDefinitionStatus { optional CustomResourceDefinitionNames acceptedNames = 2; } +// CustomResourceValidation is a list of validation methods for CustomResources. +message CustomResourceValidation { + // OpenAPIV3Schema is the OpenAPI v3 schema to be validated against. + optional JSONSchemaProps openAPIV3Schema = 1; +} + +// ExternalDocumentation allows referencing an external resource for extended documentation. +message ExternalDocumentation { + optional string description = 1; + + optional string url = 2; +} + +// JSON represents any valid JSON value. +// These types are supported: bool, int64, float64, string, []interface{}, map[string]interface{} and nil. +message JSON { + optional bytes raw = 1; +} + +// JSONSchemaProps is a JSON-Schema following Specification Draft 4 (http://json-schema.org/). +message JSONSchemaProps { + optional string id = 1; + + optional string schema = 2; + + optional string ref = 3; + + optional string description = 4; + + optional string type = 5; + + optional string format = 6; + + optional string title = 7; + + optional JSON default = 8; + + optional double maximum = 9; + + optional bool exclusiveMaximum = 10; + + optional double minimum = 11; + + optional bool exclusiveMinimum = 12; + + optional int64 maxLength = 13; + + optional int64 minLength = 14; + + optional string pattern = 15; + + optional int64 maxItems = 16; + + optional int64 minItems = 17; + + optional bool uniqueItems = 18; + + optional double multipleOf = 19; + + repeated JSON enum = 20; + + optional int64 maxProperties = 21; + + optional int64 minProperties = 22; + + repeated string required = 23; + + optional JSONSchemaPropsOrArray items = 24; + + repeated JSONSchemaProps allOf = 25; + + repeated JSONSchemaProps oneOf = 26; + + repeated JSONSchemaProps anyOf = 27; + + optional JSONSchemaProps not = 28; + + map properties = 29; + + optional JSONSchemaPropsOrBool additionalProperties = 30; + + map patternProperties = 31; + + map dependencies = 32; + + optional JSONSchemaPropsOrBool additionalItems = 33; + + map definitions = 34; + + optional ExternalDocumentation externalDocs = 35; + + optional JSON example = 36; +} + +// JSONSchemaPropsOrArray represents a value that can either be a JSONSchemaProps +// or an array of JSONSchemaProps. Mainly here for serialization purposes. +message JSONSchemaPropsOrArray { + optional JSONSchemaProps schema = 1; + + repeated JSONSchemaProps jSONSchemas = 2; +} + +// JSONSchemaPropsOrBool represents JSONSchemaProps or a boolean value. +// Defaults to true for the boolean property. +message JSONSchemaPropsOrBool { + optional bool allows = 1; + + optional JSONSchemaProps schema = 2; +} + +// JSONSchemaPropsOrStringArray represents a JSONSchemaProps or a string array. +message JSONSchemaPropsOrStringArray { + optional JSONSchemaProps schema = 1; + + repeated string property = 2; +} + diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go index cb19f35d7c7..26fcb6cc04c 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.conversion.go @@ -47,6 +47,20 @@ func RegisterConversions(scheme *runtime.Scheme) error { Convert_apiextensions_CustomResourceDefinitionSpec_To_v1beta1_CustomResourceDefinitionSpec, Convert_v1beta1_CustomResourceDefinitionStatus_To_apiextensions_CustomResourceDefinitionStatus, Convert_apiextensions_CustomResourceDefinitionStatus_To_v1beta1_CustomResourceDefinitionStatus, + Convert_v1beta1_CustomResourceValidation_To_apiextensions_CustomResourceValidation, + Convert_apiextensions_CustomResourceValidation_To_v1beta1_CustomResourceValidation, + Convert_v1beta1_ExternalDocumentation_To_apiextensions_ExternalDocumentation, + Convert_apiextensions_ExternalDocumentation_To_v1beta1_ExternalDocumentation, + Convert_v1beta1_JSON_To_apiextensions_JSON, + Convert_apiextensions_JSON_To_v1beta1_JSON, + Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps, + Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps, + Convert_v1beta1_JSONSchemaPropsOrArray_To_apiextensions_JSONSchemaPropsOrArray, + Convert_apiextensions_JSONSchemaPropsOrArray_To_v1beta1_JSONSchemaPropsOrArray, + Convert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool, + Convert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool, + Convert_v1beta1_JSONSchemaPropsOrStringArray_To_apiextensions_JSONSchemaPropsOrStringArray, + Convert_apiextensions_JSONSchemaPropsOrStringArray_To_v1beta1_JSONSchemaPropsOrStringArray, ) } @@ -112,7 +126,17 @@ func Convert_apiextensions_CustomResourceDefinitionCondition_To_v1beta1_CustomRe func autoConvert_v1beta1_CustomResourceDefinitionList_To_apiextensions_CustomResourceDefinitionList(in *CustomResourceDefinitionList, out *apiextensions.CustomResourceDefinitionList, s conversion.Scope) error { out.ListMeta = in.ListMeta - out.Items = *(*[]apiextensions.CustomResourceDefinition)(unsafe.Pointer(&in.Items)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]apiextensions.CustomResourceDefinition, len(*in)) + for i := range *in { + if err := Convert_v1beta1_CustomResourceDefinition_To_apiextensions_CustomResourceDefinition(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } return nil } @@ -123,7 +147,17 @@ func Convert_v1beta1_CustomResourceDefinitionList_To_apiextensions_CustomResourc func autoConvert_apiextensions_CustomResourceDefinitionList_To_v1beta1_CustomResourceDefinitionList(in *apiextensions.CustomResourceDefinitionList, out *CustomResourceDefinitionList, s conversion.Scope) error { out.ListMeta = in.ListMeta - out.Items = *(*[]CustomResourceDefinition)(unsafe.Pointer(&in.Items)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]CustomResourceDefinition, len(*in)) + for i := range *in { + if err := Convert_apiextensions_CustomResourceDefinition_To_v1beta1_CustomResourceDefinition(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } return nil } @@ -167,6 +201,15 @@ func autoConvert_v1beta1_CustomResourceDefinitionSpec_To_apiextensions_CustomRes return err } out.Scope = apiextensions.ResourceScope(in.Scope) + if in.Validation != nil { + in, out := &in.Validation, &out.Validation + *out = new(apiextensions.CustomResourceValidation) + if err := Convert_v1beta1_CustomResourceValidation_To_apiextensions_CustomResourceValidation(*in, *out, s); err != nil { + return err + } + } else { + out.Validation = nil + } return nil } @@ -182,6 +225,15 @@ func autoConvert_apiextensions_CustomResourceDefinitionSpec_To_v1beta1_CustomRes return err } out.Scope = ResourceScope(in.Scope) + if in.Validation != nil { + in, out := &in.Validation, &out.Validation + *out = new(CustomResourceValidation) + if err := Convert_apiextensions_CustomResourceValidation_To_v1beta1_CustomResourceValidation(*in, *out, s); err != nil { + return err + } + } else { + out.Validation = nil + } return nil } @@ -215,3 +267,562 @@ func autoConvert_apiextensions_CustomResourceDefinitionStatus_To_v1beta1_CustomR func Convert_apiextensions_CustomResourceDefinitionStatus_To_v1beta1_CustomResourceDefinitionStatus(in *apiextensions.CustomResourceDefinitionStatus, out *CustomResourceDefinitionStatus, s conversion.Scope) error { return autoConvert_apiextensions_CustomResourceDefinitionStatus_To_v1beta1_CustomResourceDefinitionStatus(in, out, s) } + +func autoConvert_v1beta1_CustomResourceValidation_To_apiextensions_CustomResourceValidation(in *CustomResourceValidation, out *apiextensions.CustomResourceValidation, s conversion.Scope) error { + if in.OpenAPIV3Schema != nil { + in, out := &in.OpenAPIV3Schema, &out.OpenAPIV3Schema + *out = new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.OpenAPIV3Schema = nil + } + return nil +} + +// Convert_v1beta1_CustomResourceValidation_To_apiextensions_CustomResourceValidation is an autogenerated conversion function. +func Convert_v1beta1_CustomResourceValidation_To_apiextensions_CustomResourceValidation(in *CustomResourceValidation, out *apiextensions.CustomResourceValidation, s conversion.Scope) error { + return autoConvert_v1beta1_CustomResourceValidation_To_apiextensions_CustomResourceValidation(in, out, s) +} + +func autoConvert_apiextensions_CustomResourceValidation_To_v1beta1_CustomResourceValidation(in *apiextensions.CustomResourceValidation, out *CustomResourceValidation, s conversion.Scope) error { + if in.OpenAPIV3Schema != nil { + in, out := &in.OpenAPIV3Schema, &out.OpenAPIV3Schema + *out = new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.OpenAPIV3Schema = nil + } + return nil +} + +// Convert_apiextensions_CustomResourceValidation_To_v1beta1_CustomResourceValidation is an autogenerated conversion function. +func Convert_apiextensions_CustomResourceValidation_To_v1beta1_CustomResourceValidation(in *apiextensions.CustomResourceValidation, out *CustomResourceValidation, s conversion.Scope) error { + return autoConvert_apiextensions_CustomResourceValidation_To_v1beta1_CustomResourceValidation(in, out, s) +} + +func autoConvert_v1beta1_ExternalDocumentation_To_apiextensions_ExternalDocumentation(in *ExternalDocumentation, out *apiextensions.ExternalDocumentation, s conversion.Scope) error { + out.Description = in.Description + out.URL = in.URL + return nil +} + +// Convert_v1beta1_ExternalDocumentation_To_apiextensions_ExternalDocumentation is an autogenerated conversion function. +func Convert_v1beta1_ExternalDocumentation_To_apiextensions_ExternalDocumentation(in *ExternalDocumentation, out *apiextensions.ExternalDocumentation, s conversion.Scope) error { + return autoConvert_v1beta1_ExternalDocumentation_To_apiextensions_ExternalDocumentation(in, out, s) +} + +func autoConvert_apiextensions_ExternalDocumentation_To_v1beta1_ExternalDocumentation(in *apiextensions.ExternalDocumentation, out *ExternalDocumentation, s conversion.Scope) error { + out.Description = in.Description + out.URL = in.URL + return nil +} + +// Convert_apiextensions_ExternalDocumentation_To_v1beta1_ExternalDocumentation is an autogenerated conversion function. +func Convert_apiextensions_ExternalDocumentation_To_v1beta1_ExternalDocumentation(in *apiextensions.ExternalDocumentation, out *ExternalDocumentation, s conversion.Scope) error { + return autoConvert_apiextensions_ExternalDocumentation_To_v1beta1_ExternalDocumentation(in, out, s) +} + +func autoConvert_v1beta1_JSON_To_apiextensions_JSON(in *JSON, out *apiextensions.JSON, s conversion.Scope) error { + // WARNING: in.Raw requires manual conversion: does not exist in peer-type + return nil +} + +func autoConvert_apiextensions_JSON_To_v1beta1_JSON(in *apiextensions.JSON, out *JSON, s conversion.Scope) error { + // FIXME: Type apiextensions.JSON is unsupported. + return nil +} + +func autoConvert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(in *JSONSchemaProps, out *apiextensions.JSONSchemaProps, s conversion.Scope) error { + out.ID = in.ID + out.Schema = apiextensions.JSONSchemaURL(in.Schema) + out.Ref = (*string)(unsafe.Pointer(in.Ref)) + out.Description = in.Description + out.Type = in.Type + out.Format = in.Format + out.Title = in.Title + if in.Default != nil { + in, out := &in.Default, &out.Default + *out = new(apiextensions.JSON) + if err := Convert_v1beta1_JSON_To_apiextensions_JSON(*in, *out, s); err != nil { + return err + } + } else { + out.Default = nil + } + out.Maximum = (*float64)(unsafe.Pointer(in.Maximum)) + out.ExclusiveMaximum = in.ExclusiveMaximum + out.Minimum = (*float64)(unsafe.Pointer(in.Minimum)) + out.ExclusiveMinimum = in.ExclusiveMinimum + out.MaxLength = (*int64)(unsafe.Pointer(in.MaxLength)) + out.MinLength = (*int64)(unsafe.Pointer(in.MinLength)) + out.Pattern = in.Pattern + out.MaxItems = (*int64)(unsafe.Pointer(in.MaxItems)) + out.MinItems = (*int64)(unsafe.Pointer(in.MinItems)) + out.UniqueItems = in.UniqueItems + out.MultipleOf = (*float64)(unsafe.Pointer(in.MultipleOf)) + if in.Enum != nil { + in, out := &in.Enum, &out.Enum + *out = make([]apiextensions.JSON, len(*in)) + for i := range *in { + if err := Convert_v1beta1_JSON_To_apiextensions_JSON(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Enum = nil + } + out.MaxProperties = (*int64)(unsafe.Pointer(in.MaxProperties)) + out.MinProperties = (*int64)(unsafe.Pointer(in.MinProperties)) + out.Required = *(*[]string)(unsafe.Pointer(&in.Required)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = new(apiextensions.JSONSchemaPropsOrArray) + if err := Convert_v1beta1_JSONSchemaPropsOrArray_To_apiextensions_JSONSchemaPropsOrArray(*in, *out, s); err != nil { + return err + } + } else { + out.Items = nil + } + if in.AllOf != nil { + in, out := &in.AllOf, &out.AllOf + *out = make([]apiextensions.JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.AllOf = nil + } + if in.OneOf != nil { + in, out := &in.OneOf, &out.OneOf + *out = make([]apiextensions.JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.OneOf = nil + } + if in.AnyOf != nil { + in, out := &in.AnyOf, &out.AnyOf + *out = make([]apiextensions.JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.AnyOf = nil + } + if in.Not != nil { + in, out := &in.Not, &out.Not + *out = new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Not = nil + } + if in.Properties != nil { + in, out := &in.Properties, &out.Properties + *out = make(map[string]apiextensions.JSONSchemaProps, len(*in)) + for key, val := range *in { + newVal := new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.Properties = nil + } + if in.AdditionalProperties != nil { + in, out := &in.AdditionalProperties, &out.AdditionalProperties + *out = new(apiextensions.JSONSchemaPropsOrBool) + if err := Convert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool(*in, *out, s); err != nil { + return err + } + } else { + out.AdditionalProperties = nil + } + if in.PatternProperties != nil { + in, out := &in.PatternProperties, &out.PatternProperties + *out = make(map[string]apiextensions.JSONSchemaProps, len(*in)) + for key, val := range *in { + newVal := new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.PatternProperties = nil + } + if in.Dependencies != nil { + in, out := &in.Dependencies, &out.Dependencies + *out = make(apiextensions.JSONSchemaDependencies, len(*in)) + for key, val := range *in { + newVal := new(apiextensions.JSONSchemaPropsOrStringArray) + if err := Convert_v1beta1_JSONSchemaPropsOrStringArray_To_apiextensions_JSONSchemaPropsOrStringArray(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.Dependencies = nil + } + if in.AdditionalItems != nil { + in, out := &in.AdditionalItems, &out.AdditionalItems + *out = new(apiextensions.JSONSchemaPropsOrBool) + if err := Convert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool(*in, *out, s); err != nil { + return err + } + } else { + out.AdditionalItems = nil + } + if in.Definitions != nil { + in, out := &in.Definitions, &out.Definitions + *out = make(apiextensions.JSONSchemaDefinitions, len(*in)) + for key, val := range *in { + newVal := new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.Definitions = nil + } + out.ExternalDocs = (*apiextensions.ExternalDocumentation)(unsafe.Pointer(in.ExternalDocs)) + if in.Example != nil { + in, out := &in.Example, &out.Example + *out = new(apiextensions.JSON) + if err := Convert_v1beta1_JSON_To_apiextensions_JSON(*in, *out, s); err != nil { + return err + } + } else { + out.Example = nil + } + return nil +} + +// Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps is an autogenerated conversion function. +func Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(in *JSONSchemaProps, out *apiextensions.JSONSchemaProps, s conversion.Scope) error { + return autoConvert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(in, out, s) +} + +func autoConvert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(in *apiextensions.JSONSchemaProps, out *JSONSchemaProps, s conversion.Scope) error { + out.ID = in.ID + out.Schema = JSONSchemaURL(in.Schema) + out.Ref = (*string)(unsafe.Pointer(in.Ref)) + out.Description = in.Description + out.Type = in.Type + out.Format = in.Format + out.Title = in.Title + if in.Default != nil { + in, out := &in.Default, &out.Default + *out = new(JSON) + if err := Convert_apiextensions_JSON_To_v1beta1_JSON(*in, *out, s); err != nil { + return err + } + } else { + out.Default = nil + } + out.Maximum = (*float64)(unsafe.Pointer(in.Maximum)) + out.ExclusiveMaximum = in.ExclusiveMaximum + out.Minimum = (*float64)(unsafe.Pointer(in.Minimum)) + out.ExclusiveMinimum = in.ExclusiveMinimum + out.MaxLength = (*int64)(unsafe.Pointer(in.MaxLength)) + out.MinLength = (*int64)(unsafe.Pointer(in.MinLength)) + out.Pattern = in.Pattern + out.MaxItems = (*int64)(unsafe.Pointer(in.MaxItems)) + out.MinItems = (*int64)(unsafe.Pointer(in.MinItems)) + out.UniqueItems = in.UniqueItems + out.MultipleOf = (*float64)(unsafe.Pointer(in.MultipleOf)) + if in.Enum != nil { + in, out := &in.Enum, &out.Enum + *out = make([]JSON, len(*in)) + for i := range *in { + if err := Convert_apiextensions_JSON_To_v1beta1_JSON(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Enum = nil + } + out.MaxProperties = (*int64)(unsafe.Pointer(in.MaxProperties)) + out.MinProperties = (*int64)(unsafe.Pointer(in.MinProperties)) + out.Required = *(*[]string)(unsafe.Pointer(&in.Required)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = new(JSONSchemaPropsOrArray) + if err := Convert_apiextensions_JSONSchemaPropsOrArray_To_v1beta1_JSONSchemaPropsOrArray(*in, *out, s); err != nil { + return err + } + } else { + out.Items = nil + } + if in.AllOf != nil { + in, out := &in.AllOf, &out.AllOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.AllOf = nil + } + if in.OneOf != nil { + in, out := &in.OneOf, &out.OneOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.OneOf = nil + } + if in.AnyOf != nil { + in, out := &in.AnyOf, &out.AnyOf + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.AnyOf = nil + } + if in.Not != nil { + in, out := &in.Not, &out.Not + *out = new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Not = nil + } + if in.Properties != nil { + in, out := &in.Properties, &out.Properties + *out = make(map[string]JSONSchemaProps, len(*in)) + for key, val := range *in { + newVal := new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.Properties = nil + } + if in.AdditionalProperties != nil { + in, out := &in.AdditionalProperties, &out.AdditionalProperties + *out = new(JSONSchemaPropsOrBool) + if err := Convert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool(*in, *out, s); err != nil { + return err + } + } else { + out.AdditionalProperties = nil + } + if in.PatternProperties != nil { + in, out := &in.PatternProperties, &out.PatternProperties + *out = make(map[string]JSONSchemaProps, len(*in)) + for key, val := range *in { + newVal := new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.PatternProperties = nil + } + if in.Dependencies != nil { + in, out := &in.Dependencies, &out.Dependencies + *out = make(JSONSchemaDependencies, len(*in)) + for key, val := range *in { + newVal := new(JSONSchemaPropsOrStringArray) + if err := Convert_apiextensions_JSONSchemaPropsOrStringArray_To_v1beta1_JSONSchemaPropsOrStringArray(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.Dependencies = nil + } + if in.AdditionalItems != nil { + in, out := &in.AdditionalItems, &out.AdditionalItems + *out = new(JSONSchemaPropsOrBool) + if err := Convert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool(*in, *out, s); err != nil { + return err + } + } else { + out.AdditionalItems = nil + } + if in.Definitions != nil { + in, out := &in.Definitions, &out.Definitions + *out = make(JSONSchemaDefinitions, len(*in)) + for key, val := range *in { + newVal := new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&val, newVal, s); err != nil { + return err + } + (*out)[key] = *newVal + } + } else { + out.Definitions = nil + } + out.ExternalDocs = (*ExternalDocumentation)(unsafe.Pointer(in.ExternalDocs)) + if in.Example != nil { + in, out := &in.Example, &out.Example + *out = new(JSON) + if err := Convert_apiextensions_JSON_To_v1beta1_JSON(*in, *out, s); err != nil { + return err + } + } else { + out.Example = nil + } + return nil +} + +func autoConvert_v1beta1_JSONSchemaPropsOrArray_To_apiextensions_JSONSchemaPropsOrArray(in *JSONSchemaPropsOrArray, out *apiextensions.JSONSchemaPropsOrArray, s conversion.Scope) error { + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Schema = nil + } + if in.JSONSchemas != nil { + in, out := &in.JSONSchemas, &out.JSONSchemas + *out = make([]apiextensions.JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.JSONSchemas = nil + } + return nil +} + +// Convert_v1beta1_JSONSchemaPropsOrArray_To_apiextensions_JSONSchemaPropsOrArray is an autogenerated conversion function. +func Convert_v1beta1_JSONSchemaPropsOrArray_To_apiextensions_JSONSchemaPropsOrArray(in *JSONSchemaPropsOrArray, out *apiextensions.JSONSchemaPropsOrArray, s conversion.Scope) error { + return autoConvert_v1beta1_JSONSchemaPropsOrArray_To_apiextensions_JSONSchemaPropsOrArray(in, out, s) +} + +func autoConvert_apiextensions_JSONSchemaPropsOrArray_To_v1beta1_JSONSchemaPropsOrArray(in *apiextensions.JSONSchemaPropsOrArray, out *JSONSchemaPropsOrArray, s conversion.Scope) error { + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Schema = nil + } + if in.JSONSchemas != nil { + in, out := &in.JSONSchemas, &out.JSONSchemas + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.JSONSchemas = nil + } + return nil +} + +// Convert_apiextensions_JSONSchemaPropsOrArray_To_v1beta1_JSONSchemaPropsOrArray is an autogenerated conversion function. +func Convert_apiextensions_JSONSchemaPropsOrArray_To_v1beta1_JSONSchemaPropsOrArray(in *apiextensions.JSONSchemaPropsOrArray, out *JSONSchemaPropsOrArray, s conversion.Scope) error { + return autoConvert_apiextensions_JSONSchemaPropsOrArray_To_v1beta1_JSONSchemaPropsOrArray(in, out, s) +} + +func autoConvert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool(in *JSONSchemaPropsOrBool, out *apiextensions.JSONSchemaPropsOrBool, s conversion.Scope) error { + out.Allows = in.Allows + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Schema = nil + } + return nil +} + +// Convert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool is an autogenerated conversion function. +func Convert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool(in *JSONSchemaPropsOrBool, out *apiextensions.JSONSchemaPropsOrBool, s conversion.Scope) error { + return autoConvert_v1beta1_JSONSchemaPropsOrBool_To_apiextensions_JSONSchemaPropsOrBool(in, out, s) +} + +func autoConvert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool(in *apiextensions.JSONSchemaPropsOrBool, out *JSONSchemaPropsOrBool, s conversion.Scope) error { + out.Allows = in.Allows + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Schema = nil + } + return nil +} + +// Convert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool is an autogenerated conversion function. +func Convert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool(in *apiextensions.JSONSchemaPropsOrBool, out *JSONSchemaPropsOrBool, s conversion.Scope) error { + return autoConvert_apiextensions_JSONSchemaPropsOrBool_To_v1beta1_JSONSchemaPropsOrBool(in, out, s) +} + +func autoConvert_v1beta1_JSONSchemaPropsOrStringArray_To_apiextensions_JSONSchemaPropsOrStringArray(in *JSONSchemaPropsOrStringArray, out *apiextensions.JSONSchemaPropsOrStringArray, s conversion.Scope) error { + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(apiextensions.JSONSchemaProps) + if err := Convert_v1beta1_JSONSchemaProps_To_apiextensions_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Schema = nil + } + out.Property = *(*[]string)(unsafe.Pointer(&in.Property)) + return nil +} + +// Convert_v1beta1_JSONSchemaPropsOrStringArray_To_apiextensions_JSONSchemaPropsOrStringArray is an autogenerated conversion function. +func Convert_v1beta1_JSONSchemaPropsOrStringArray_To_apiextensions_JSONSchemaPropsOrStringArray(in *JSONSchemaPropsOrStringArray, out *apiextensions.JSONSchemaPropsOrStringArray, s conversion.Scope) error { + return autoConvert_v1beta1_JSONSchemaPropsOrStringArray_To_apiextensions_JSONSchemaPropsOrStringArray(in, out, s) +} + +func autoConvert_apiextensions_JSONSchemaPropsOrStringArray_To_v1beta1_JSONSchemaPropsOrStringArray(in *apiextensions.JSONSchemaPropsOrStringArray, out *JSONSchemaPropsOrStringArray, s conversion.Scope) error { + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + *out = new(JSONSchemaProps) + if err := Convert_apiextensions_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil { + return err + } + } else { + out.Schema = nil + } + out.Property = *(*[]string)(unsafe.Pointer(&in.Property)) + return nil +} + +// Convert_apiextensions_JSONSchemaPropsOrStringArray_To_v1beta1_JSONSchemaPropsOrStringArray is an autogenerated conversion function. +func Convert_apiextensions_JSONSchemaPropsOrStringArray_To_v1beta1_JSONSchemaPropsOrStringArray(in *apiextensions.JSONSchemaPropsOrStringArray, out *JSONSchemaPropsOrStringArray, s conversion.Scope) error { + return autoConvert_apiextensions_JSONSchemaPropsOrStringArray_To_v1beta1_JSONSchemaPropsOrStringArray(in, out, s) +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go index 31feff62d66..6f97eb6db63 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/zz_generated.deepcopy.go @@ -60,6 +60,34 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*CustomResourceDefinitionStatus).DeepCopyInto(out.(*CustomResourceDefinitionStatus)) return nil }, InType: reflect.TypeOf(&CustomResourceDefinitionStatus{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*CustomResourceValidation).DeepCopyInto(out.(*CustomResourceValidation)) + return nil + }, InType: reflect.TypeOf(&CustomResourceValidation{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ExternalDocumentation).DeepCopyInto(out.(*ExternalDocumentation)) + return nil + }, InType: reflect.TypeOf(&ExternalDocumentation{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSON).DeepCopyInto(out.(*JSON)) + return nil + }, InType: reflect.TypeOf(&JSON{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaProps).DeepCopyInto(out.(*JSONSchemaProps)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaProps{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaPropsOrArray).DeepCopyInto(out.(*JSONSchemaPropsOrArray)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaPropsOrArray{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaPropsOrBool).DeepCopyInto(out.(*JSONSchemaPropsOrBool)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaPropsOrBool{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaPropsOrStringArray).DeepCopyInto(out.(*JSONSchemaPropsOrStringArray)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaPropsOrStringArray{})}, ) } @@ -168,6 +196,15 @@ func (in *CustomResourceDefinitionNames) DeepCopy() *CustomResourceDefinitionNam func (in *CustomResourceDefinitionSpec) DeepCopyInto(out *CustomResourceDefinitionSpec) { *out = *in in.Names.DeepCopyInto(&out.Names) + if in.Validation != nil { + in, out := &in.Validation, &out.Validation + if *in == nil { + *out = nil + } else { + *out = new(CustomResourceValidation) + (*in).DeepCopyInto(*out) + } + } return } @@ -204,3 +241,159 @@ func (in *CustomResourceDefinitionStatus) DeepCopy() *CustomResourceDefinitionSt in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CustomResourceValidation) DeepCopyInto(out *CustomResourceValidation) { + *out = *in + if in.OpenAPIV3Schema != nil { + in, out := &in.OpenAPIV3Schema, &out.OpenAPIV3Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CustomResourceValidation. +func (in *CustomResourceValidation) DeepCopy() *CustomResourceValidation { + if in == nil { + return nil + } + out := new(CustomResourceValidation) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalDocumentation) DeepCopyInto(out *ExternalDocumentation) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalDocumentation. +func (in *ExternalDocumentation) DeepCopy() *ExternalDocumentation { + if in == nil { + return nil + } + out := new(ExternalDocumentation) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSON) DeepCopyInto(out *JSON) { + *out = *in + if in.Raw != nil { + in, out := &in.Raw, &out.Raw + *out = make([]byte, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSON. +func (in *JSON) DeepCopy() *JSON { + if in == nil { + return nil + } + out := new(JSON) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaProps) DeepCopyInto(out *JSONSchemaProps) { + clone := in.DeepCopy() + *out = *clone + return +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaPropsOrArray) DeepCopyInto(out *JSONSchemaPropsOrArray) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + if in.JSONSchemas != nil { + in, out := &in.JSONSchemas, &out.JSONSchemas + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaPropsOrArray. +func (in *JSONSchemaPropsOrArray) DeepCopy() *JSONSchemaPropsOrArray { + if in == nil { + return nil + } + out := new(JSONSchemaPropsOrArray) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaPropsOrBool) DeepCopyInto(out *JSONSchemaPropsOrBool) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaPropsOrBool. +func (in *JSONSchemaPropsOrBool) DeepCopy() *JSONSchemaPropsOrBool { + if in == nil { + return nil + } + out := new(JSONSchemaPropsOrBool) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaPropsOrStringArray) DeepCopyInto(out *JSONSchemaPropsOrStringArray) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + if in.Property != nil { + in, out := &in.Property, &out.Property + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaPropsOrStringArray. +func (in *JSONSchemaPropsOrStringArray) DeepCopy() *JSONSchemaPropsOrStringArray { + if in == nil { + return nil + } + out := new(JSONSchemaPropsOrStringArray) + in.DeepCopyInto(out) + return out +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go index a6e55d4084d..ae6f2d79f89 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/zz_generated.deepcopy.go @@ -60,6 +60,30 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { in.(*CustomResourceDefinitionStatus).DeepCopyInto(out.(*CustomResourceDefinitionStatus)) return nil }, InType: reflect.TypeOf(&CustomResourceDefinitionStatus{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*CustomResourceValidation).DeepCopyInto(out.(*CustomResourceValidation)) + return nil + }, InType: reflect.TypeOf(&CustomResourceValidation{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*ExternalDocumentation).DeepCopyInto(out.(*ExternalDocumentation)) + return nil + }, InType: reflect.TypeOf(&ExternalDocumentation{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaProps).DeepCopyInto(out.(*JSONSchemaProps)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaProps{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaPropsOrArray).DeepCopyInto(out.(*JSONSchemaPropsOrArray)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaPropsOrArray{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaPropsOrBool).DeepCopyInto(out.(*JSONSchemaPropsOrBool)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaPropsOrBool{})}, + conversion.GeneratedDeepCopyFunc{Fn: func(in interface{}, out interface{}, c *conversion.Cloner) error { + in.(*JSONSchemaPropsOrStringArray).DeepCopyInto(out.(*JSONSchemaPropsOrStringArray)) + return nil + }, InType: reflect.TypeOf(&JSONSchemaPropsOrStringArray{})}, ) } @@ -168,6 +192,15 @@ func (in *CustomResourceDefinitionNames) DeepCopy() *CustomResourceDefinitionNam func (in *CustomResourceDefinitionSpec) DeepCopyInto(out *CustomResourceDefinitionSpec) { *out = *in in.Names.DeepCopyInto(&out.Names) + if in.Validation != nil { + in, out := &in.Validation, &out.Validation + if *in == nil { + *out = nil + } else { + *out = new(CustomResourceValidation) + (*in).DeepCopyInto(*out) + } + } return } @@ -204,3 +237,138 @@ func (in *CustomResourceDefinitionStatus) DeepCopy() *CustomResourceDefinitionSt in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CustomResourceValidation) DeepCopyInto(out *CustomResourceValidation) { + *out = *in + if in.OpenAPIV3Schema != nil { + in, out := &in.OpenAPIV3Schema, &out.OpenAPIV3Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CustomResourceValidation. +func (in *CustomResourceValidation) DeepCopy() *CustomResourceValidation { + if in == nil { + return nil + } + out := new(CustomResourceValidation) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalDocumentation) DeepCopyInto(out *ExternalDocumentation) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalDocumentation. +func (in *ExternalDocumentation) DeepCopy() *ExternalDocumentation { + if in == nil { + return nil + } + out := new(ExternalDocumentation) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaProps) DeepCopyInto(out *JSONSchemaProps) { + clone := in.DeepCopy() + *out = *clone + return +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaPropsOrArray) DeepCopyInto(out *JSONSchemaPropsOrArray) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + if in.JSONSchemas != nil { + in, out := &in.JSONSchemas, &out.JSONSchemas + *out = make([]JSONSchemaProps, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaPropsOrArray. +func (in *JSONSchemaPropsOrArray) DeepCopy() *JSONSchemaPropsOrArray { + if in == nil { + return nil + } + out := new(JSONSchemaPropsOrArray) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaPropsOrBool) DeepCopyInto(out *JSONSchemaPropsOrBool) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaPropsOrBool. +func (in *JSONSchemaPropsOrBool) DeepCopy() *JSONSchemaPropsOrBool { + if in == nil { + return nil + } + out := new(JSONSchemaPropsOrBool) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JSONSchemaPropsOrStringArray) DeepCopyInto(out *JSONSchemaPropsOrStringArray) { + *out = *in + if in.Schema != nil { + in, out := &in.Schema, &out.Schema + if *in == nil { + *out = nil + } else { + *out = new(JSONSchemaProps) + (*in).DeepCopyInto(*out) + } + } + if in.Property != nil { + in, out := &in.Property, &out.Property + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JSONSchemaPropsOrStringArray. +func (in *JSONSchemaPropsOrStringArray) DeepCopy() *JSONSchemaPropsOrStringArray { + if in == nil { + return nil + } + out := new(JSONSchemaPropsOrStringArray) + in.DeepCopyInto(out) + return out +} From fd09c3dbb67374e4f4b46b820b5cd3d9a3124cda Mon Sep 17 00:00:00 2001 From: Nikhita Raghunath Date: Fri, 23 Jun 2017 05:02:23 +0530 Subject: [PATCH 3/6] Validate CustomResource * convert our types to openAPI types * update strategy to include crd * use strategy to validate customresource * add helper funcs * Fix conversion of empty ref field * add validation for forbidden fields * add defaulting for schema field * Validate CRD Schema --- .../pkg/apis/apiextensions/v1beta1/BUILD | 1 + .../pkg/apis/apiextensions/validation/BUILD | 3 + .../apiextensions/validation/validation.go | 172 +++++++++++++- .../pkg/apiserver/BUILD | 9 +- .../pkg/apiserver/apiserver.go | 1 + .../pkg/apiserver/customresource_handler.go | 65 +++++- .../pkg/apiserver/validation/BUILD | 32 +++ .../pkg/apiserver/validation/validation.go | 217 ++++++++++++++++++ .../pkg/registry/customresource/BUILD | 2 + .../pkg/registry/customresource/strategy.go | 31 ++- 10 files changed, 524 insertions(+), 9 deletions(-) create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/BUILD create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD index 421014e87c8..93a07cfe7a1 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1/BUILD @@ -24,6 +24,7 @@ go_library( ], deps = [ "//vendor/github.com/gogo/protobuf/proto:go_default_library", + "//vendor/github.com/gogo/protobuf/sortkeys:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions:go_default_library", "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library", diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/BUILD index 53c042aeaf6..201115a4ef4 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/BUILD @@ -10,10 +10,13 @@ go_library( name = "go_default_library", srcs = ["validation.go"], deps = [ + "//vendor/github.com/go-openapi/spec:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions:go_default_library", + "//vendor/k8s.io/apiextensions-apiserver/pkg/features:go_default_library", "//vendor/k8s.io/apimachinery/pkg/api/validation:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/validation:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/validation/field:go_default_library", + "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library", ], ) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go index 6623b0478a8..f064b99333c 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation/validation.go @@ -20,10 +20,15 @@ import ( "fmt" "strings" - "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" + "github.com/go-openapi/spec" + genericvalidation "k8s.io/apimachinery/pkg/api/validation" validationutil "k8s.io/apimachinery/pkg/util/validation" "k8s.io/apimachinery/pkg/util/validation/field" + utilfeature "k8s.io/apiserver/pkg/util/feature" + + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" + apiextensionsfeatures "k8s.io/apiextensions-apiserver/pkg/features" ) // ValidateCustomResourceDefinition statically validates @@ -100,6 +105,12 @@ func ValidateCustomResourceDefinitionSpec(spec *apiextensions.CustomResourceDefi allErrs = append(allErrs, ValidateCustomResourceDefinitionNames(&spec.Names, fldPath.Child("names"))...) + if utilfeature.DefaultFeatureGate.Enabled(apiextensionsfeatures.CustomResourceValidation) { + allErrs = append(allErrs, ValidateCustomResourceDefinitionValidation(spec.Validation, fldPath.Child("validation"))...) + } else if spec.Validation != nil { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("validation"), "disabled by feature-gate")) + } + return allErrs } @@ -158,3 +169,162 @@ func ValidateCustomResourceDefinitionNames(names *apiextensions.CustomResourceDe return allErrs } + +// specStandardValidator applies validations for different OpenAPI specfication versions. +type specStandardValidator interface { + validate(spec *apiextensions.JSONSchemaProps, fldPath *field.Path) field.ErrorList +} + +// ValidateCustomResourceDefinitionValidation statically validates +func ValidateCustomResourceDefinitionValidation(customResourceValidation *apiextensions.CustomResourceValidation, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + + if customResourceValidation == nil { + return allErrs + } + + if customResourceValidation.OpenAPIV3Schema != nil { + openAPIV3Schema := &specStandardValidatorV3{} + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(customResourceValidation.OpenAPIV3Schema, fldPath.Child("openAPIV3Schema"), openAPIV3Schema)...) + } + + return allErrs +} + +// ValidateCustomResourceDefinitionOpenAPISchema statically validates +func ValidateCustomResourceDefinitionOpenAPISchema(schema *apiextensions.JSONSchemaProps, fldPath *field.Path, ssv specStandardValidator) field.ErrorList { + allErrs := field.ErrorList{} + + if schema == nil { + return allErrs + } + + allErrs = append(allErrs, ssv.validate(schema, fldPath)...) + + if schema.UniqueItems == true { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("uniqueItems"), "uniqueItems cannot be set to true since the runtime complexity becomes quadratic")) + } + + // additionalProperties contradicts Kubernetes API convention to ignore unknown fields + if schema.AdditionalProperties != nil { + if schema.AdditionalProperties.Allows == false { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("additionalProperties"), "additionalProperties cannot be set to false")) + } + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(schema.AdditionalProperties.Schema, fldPath.Child("additionalProperties"), ssv)...) + } + + if schema.Ref != nil { + openapiRef, err := spec.NewRef(*schema.Ref) + if err != nil { + allErrs = append(allErrs, field.Invalid(fldPath.Child("ref"), *schema.Ref, err.Error())) + } + + if !openapiRef.IsValidURI() { + allErrs = append(allErrs, field.Invalid(fldPath.Child("ref"), *schema.Ref, "ref does not point to a valid URI")) + } + } + + if schema.AdditionalItems != nil { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(schema.AdditionalItems.Schema, fldPath.Child("additionalItems"), ssv)...) + } + + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(schema.Not, fldPath.Child("not"), ssv)...) + + if len(schema.AllOf) != 0 { + for _, jsonSchema := range schema.AllOf { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("allOf"), ssv)...) + } + } + + if len(schema.OneOf) != 0 { + for _, jsonSchema := range schema.OneOf { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("oneOf"), ssv)...) + } + } + + if len(schema.AnyOf) != 0 { + for _, jsonSchema := range schema.AnyOf { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("anyOf"), ssv)...) + } + } + + if len(schema.Properties) != 0 { + for property, jsonSchema := range schema.Properties { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("properties").Key(property), ssv)...) + } + } + + if len(schema.PatternProperties) != 0 { + for property, jsonSchema := range schema.PatternProperties { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("patternProperties").Key(property), ssv)...) + } + } + + if len(schema.Definitions) != 0 { + for definition, jsonSchema := range schema.Definitions { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("definitions").Key(definition), ssv)...) + } + } + + if schema.Items != nil { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(schema.Items.Schema, fldPath.Child("items"), ssv)...) + if len(schema.Items.JSONSchemas) != 0 { + for _, jsonSchema := range schema.Items.JSONSchemas { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(&jsonSchema, fldPath.Child("items"), ssv)...) + } + } + } + + if schema.Dependencies != nil { + for dependency, jsonSchemaPropsOrStringArray := range schema.Dependencies { + allErrs = append(allErrs, ValidateCustomResourceDefinitionOpenAPISchema(jsonSchemaPropsOrStringArray.Schema, fldPath.Child("dependencies").Key(dependency), ssv)...) + } + } + + return allErrs +} + +type specStandardValidatorV3 struct{} + +// validate validates against OpenAPI Schema v3. +func (v *specStandardValidatorV3) validate(schema *apiextensions.JSONSchemaProps, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + + if schema == nil { + return allErrs + } + + if schema.Default != nil { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("default"), "default is not supported")) + } + + if schema.ID != "" { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("id"), "id is not supported")) + } + + if schema.AdditionalItems != nil { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("additionalItems"), "additionalItems is not supported")) + } + + if len(schema.PatternProperties) != 0 { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("patternProperties"), "patternProperties is not supported")) + } + + if len(schema.Definitions) != 0 { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("definitions"), "definitions is not supported")) + } + + if schema.Dependencies != nil { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("dependencies"), "dependencies is not supported")) + } + + if schema.Type == "null" { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("type"), "type cannot be set to null")) + } + + if schema.Items != nil && len(schema.Items.JSONSchemas) != 0 { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("items"), "items must be a schema object and not an array")) + } + + return allErrs +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/BUILD index e14bf33317e..eb29291c7d4 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/BUILD @@ -14,10 +14,14 @@ go_library( "customresource_handler.go", ], deps = [ + "//vendor/github.com/go-openapi/spec:go_default_library", + "//vendor/github.com/go-openapi/strfmt:go_default_library", + "//vendor/github.com/go-openapi/validate:go_default_library", "//vendor/github.com/golang/glog:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/install:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1:go_default_library", + "//vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/validation:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/client/clientset/internalclientset:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/client/informers/externalversions:go_default_library", @@ -68,6 +72,9 @@ filegroup( filegroup( name = "all-srcs", - srcs = [":package-srcs"], + srcs = [ + ":package-srcs", + "//staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation:all-srcs", + ], tags = ["automanaged"], ) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go index e178bd140a6..1d1409d9a4d 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go @@ -171,6 +171,7 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) groupDiscoveryHandler, s.GenericAPIServer.RequestContextMapper(), s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions().Lister(), + s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), delegateHandler, c.CRDRESTOptionsGetter, c.GenericConfig.AdmissionControl, diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/customresource_handler.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/customresource_handler.go index 4c0002b6cee..a64f0260efe 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/customresource_handler.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/customresource_handler.go @@ -26,6 +26,11 @@ import ( "sync/atomic" "time" + openapispec "github.com/go-openapi/spec" + "github.com/go-openapi/strfmt" + "github.com/go-openapi/validate" + "github.com/golang/glog" + apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -44,8 +49,11 @@ import ( genericregistry "k8s.io/apiserver/pkg/registry/generic/registry" "k8s.io/apiserver/pkg/storage/storagebackend" "k8s.io/client-go/discovery" + cache "k8s.io/client-go/tools/cache" "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" + apiservervalidation "k8s.io/apiextensions-apiserver/pkg/apiserver/validation" + informers "k8s.io/apiextensions-apiserver/pkg/client/informers/internalversion/apiextensions/internalversion" listers "k8s.io/apiextensions-apiserver/pkg/client/listers/apiextensions/internalversion" "k8s.io/apiextensions-apiserver/pkg/controller/finalizer" "k8s.io/apiextensions-apiserver/pkg/registry/customresource" @@ -84,6 +92,7 @@ func NewCustomResourceDefinitionHandler( groupDiscoveryHandler *groupDiscoveryHandler, requestContextMapper apirequest.RequestContextMapper, crdLister listers.CustomResourceDefinitionLister, + crdInformer informers.CustomResourceDefinitionInformer, delegate http.Handler, restOptionsGetter generic.RESTOptionsGetter, admission admission.Interface) *crdHandler { @@ -98,6 +107,10 @@ func NewCustomResourceDefinitionHandler( admission: admission, } + crdInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{ + UpdateFunc: ret.updateCustomResourceDefinition, + }) + ret.customStorage.Store(crdStorageMap{}) return ret } @@ -155,7 +168,12 @@ func (r *crdHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) { terminating := apiextensions.IsCRDConditionTrue(crd, apiextensions.Terminating) - crdInfo := r.getServingInfoFor(crd) + crdInfo, err := r.getServingInfoFor(crd) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + storage := crdInfo.storage requestScope := crdInfo.requestScope minRequestTimeout := 1 * time.Minute @@ -250,15 +268,18 @@ func (r *crdHandler) removeDeadStorage() { // GetCustomResourceListerCollectionDeleter returns the ListerCollectionDeleter for // the given uid, or nil if one does not exist. func (r *crdHandler) GetCustomResourceListerCollectionDeleter(crd *apiextensions.CustomResourceDefinition) finalizer.ListerCollectionDeleter { - info := r.getServingInfoFor(crd) + info, err := r.getServingInfoFor(crd) + if err != nil { + utilruntime.HandleError(err) + } return info.storage } -func (r *crdHandler) getServingInfoFor(crd *apiextensions.CustomResourceDefinition) *crdInfo { +func (r *crdHandler) getServingInfoFor(crd *apiextensions.CustomResourceDefinition) (*crdInfo, error) { storageMap := r.customStorage.Load().(crdStorageMap) ret, ok := storageMap[crd.UID] if ok { - return ret + return ret, nil } r.customStorageLock.Lock() @@ -266,7 +287,7 @@ func (r *crdHandler) getServingInfoFor(crd *apiextensions.CustomResourceDefiniti ret, ok = storageMap[crd.UID] if ok { - return ret + return ret, nil } // In addition to Unstructured objects (Custom Resources), we also may sometimes need to @@ -287,6 +308,17 @@ func (r *crdHandler) getServingInfoFor(crd *apiextensions.CustomResourceDefiniti unstructuredTyper: discovery.NewUnstructuredObjectTyper(nil), } creator := unstructuredCreator{} + + // convert CRD schema to openapi schema + openapiSchema := &openapispec.Schema{} + if err := apiservervalidation.ConvertToOpenAPITypes(crd, openapiSchema); err != nil { + return nil, err + } + if err := openapispec.ExpandSchema(openapiSchema, nil, nil); err != nil { + return nil, err + } + validator := validate.NewSchemaValidator(openapiSchema, nil, "", strfmt.Default) + storage := customresource.NewREST( schema.GroupResource{Group: crd.Spec.Group, Resource: crd.Spec.Names.Plural}, schema.GroupVersionKind{Group: crd.Spec.Group, Version: crd.Spec.Version, Kind: crd.Spec.Names.ListKind}, @@ -295,6 +327,7 @@ func (r *crdHandler) getServingInfoFor(crd *apiextensions.CustomResourceDefiniti typer, crd.Spec.Scope == apiextensions.NamespaceScoped, kind, + validator, ), r.restOptionsGetter, ) @@ -354,7 +387,27 @@ func (r *crdHandler) getServingInfoFor(crd *apiextensions.CustomResourceDefiniti storageMap2[crd.UID] = ret r.customStorage.Store(storageMap2) - return ret + return ret, nil +} + +func (c *crdHandler) updateCustomResourceDefinition(oldObj, _ interface{}) { + oldCRD := oldObj.(*apiextensions.CustomResourceDefinition) + glog.V(4).Infof("Updating customresourcedefinition %s", oldCRD.Name) + + c.customStorageLock.Lock() + defer c.customStorageLock.Unlock() + + storageMap := c.customStorage.Load().(crdStorageMap) + storageMap2 := make(crdStorageMap, len(storageMap)) + + // Copy because we cannot write to storageMap without a race + // as it is used without locking elsewhere + for k, v := range storageMap { + storageMap2[k] = v + } + + delete(storageMap2, oldCRD.UID) + c.customStorage.Store(storageMap2) } type unstructuredNegotiatedSerializer struct { diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/BUILD new file mode 100644 index 00000000000..b64622758b0 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/BUILD @@ -0,0 +1,32 @@ +package(default_visibility = ["//visibility:public"]) + +licenses(["notice"]) + +load( + "@io_bazel_rules_go//go:def.bzl", + "go_library", +) + +go_library( + name = "go_default_library", + srcs = ["validation.go"], + tags = ["automanaged"], + deps = [ + "//vendor/github.com/go-openapi/spec:go_default_library", + "//vendor/github.com/go-openapi/validate:go_default_library", + "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], +) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go new file mode 100644 index 00000000000..4c5e62851e1 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go @@ -0,0 +1,217 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package validation + +import ( + "github.com/go-openapi/spec" + "github.com/go-openapi/validate" + + "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" +) + +// ValidateCustomResource validates the Custom Resource against the schema in the CustomResourceDefinition. +// CustomResource is a JSON data structure. +func ValidateCustomResource(customResource interface{}, validator *validate.SchemaValidator) error { + result := validator.Validate(customResource) + if result.AsError() != nil { + return result.AsError() + } + return nil +} + +// ConvertToOpenAPITypes is used to convert internal types to go-openapi types. +func ConvertToOpenAPITypes(in *apiextensions.CustomResourceDefinition, out *spec.Schema) error { + if in.Spec.Validation != nil { + if err := convertJSONSchemaProps(in.Spec.Validation.OpenAPIV3Schema, out); err != nil { + return err + } + } + + return nil +} + +func convertJSONSchemaProps(in *apiextensions.JSONSchemaProps, out *spec.Schema) error { + if in == nil { + return nil + } + + out.ID = in.ID + out.Schema = spec.SchemaURL(in.Schema) + out.Description = in.Description + if in.Type != "" { + out.Type = spec.StringOrArray([]string{in.Type}) + } + out.Format = in.Format + out.Title = in.Title + out.ExclusiveMaximum = in.ExclusiveMaximum + out.Minimum = in.Minimum + out.ExclusiveMinimum = in.ExclusiveMinimum + out.MaxLength = in.MaxLength + out.MinLength = in.MinLength + out.Pattern = in.Pattern + out.MaxItems = in.MaxItems + out.MinItems = in.MinItems + out.UniqueItems = in.UniqueItems + out.MultipleOf = in.MultipleOf + out.MaxProperties = in.MaxProperties + out.MinProperties = in.MinProperties + out.Required = in.Required + + if in.Default != nil { + out.Default = *(in.Default) + } + if in.Example != nil { + out.Example = *(in.Example) + } + + out.Enum = make([]interface{}, len(in.Enum)) + for k, v := range in.Enum { + out.Enum[k] = v + } + + if err := convertJSONSchemaPropsOrArray(in.Items, out.Items); err != nil { + return err + } + if err := convertSliceOfJSONSchemaProps(&in.AllOf, &out.AllOf); err != nil { + return err + } + if err := convertSliceOfJSONSchemaProps(&in.OneOf, &out.OneOf); err != nil { + return err + } + if err := convertSliceOfJSONSchemaProps(&in.AnyOf, &out.AnyOf); err != nil { + return err + } + if err := convertJSONSchemaProps(in.Not, out.Not); err != nil { + return err + } + + var err error + out.Properties, err = convertMapOfJSONSchemaProps(in.Properties) + if err != nil { + return err + } + + out.PatternProperties, err = convertMapOfJSONSchemaProps(in.PatternProperties) + if err != nil { + return err + } + + if in.Ref != nil { + out.Ref, err = spec.NewRef(*in.Ref) + if err != nil { + return err + } + } + + if err := convertJSONSchemaPropsorBool(in.AdditionalProperties, out.AdditionalProperties); err != nil { + return err + } + + if err := convertJSONSchemaPropsorBool(in.AdditionalItems, out.AdditionalItems); err != nil { + return err + } + + if err := convertJSONSchemaDependencies(in.Dependencies, out.Dependencies); err != nil { + return err + } + + out.Definitions, err = convertMapOfJSONSchemaProps(in.Definitions) + if err != nil { + return err + } + + if in.ExternalDocs != nil { + out.ExternalDocs = &spec.ExternalDocumentation{} + out.ExternalDocs.Description = in.ExternalDocs.Description + out.ExternalDocs.URL = in.ExternalDocs.URL + } + + return nil +} + +func convertSliceOfJSONSchemaProps(in *[]apiextensions.JSONSchemaProps, out *[]spec.Schema) error { + if in != nil { + for _, jsonSchemaProps := range *in { + schema := spec.Schema{} + if err := convertJSONSchemaProps(&jsonSchemaProps, &schema); err != nil { + return err + } + *out = append(*out, schema) + } + } + return nil +} + +func convertMapOfJSONSchemaProps(in map[string]apiextensions.JSONSchemaProps) (map[string]spec.Schema, error) { + out := make(map[string]spec.Schema) + if len(in) != 0 { + for k, jsonSchemaProps := range in { + schema := spec.Schema{} + if err := convertJSONSchemaProps(&jsonSchemaProps, &schema); err != nil { + return nil, err + } + out[k] = schema + } + } + return out, nil +} + +func convertJSONSchemaPropsOrArray(in *apiextensions.JSONSchemaPropsOrArray, out *spec.SchemaOrArray) error { + if in != nil { + out.Schema = &spec.Schema{} + if err := convertJSONSchemaProps(in.Schema, out.Schema); err != nil { + return err + } + } + return nil +} + +func convertJSONSchemaPropsorBool(in *apiextensions.JSONSchemaPropsOrBool, out *spec.SchemaOrBool) error { + if in != nil { + out = &spec.SchemaOrBool{} + out.Allows = in.Allows + out.Schema = &spec.Schema{} + if err := convertJSONSchemaProps(in.Schema, out.Schema); err != nil { + return err + } + } + return nil +} + +func convertJSONSchemaPropsOrStringArray(in *apiextensions.JSONSchemaPropsOrStringArray, out *spec.SchemaOrStringArray) error { + if in != nil { + out.Property = in.Property + out.Schema = &spec.Schema{} + if err := convertJSONSchemaProps(in.Schema, out.Schema); err != nil { + return err + } + } + return nil +} + +func convertJSONSchemaDependencies(in apiextensions.JSONSchemaDependencies, out spec.Dependencies) error { + if in != nil { + for k, v := range in { + schemaOrArray := spec.SchemaOrStringArray{} + if err := convertJSONSchemaPropsOrStringArray(&v, &schemaOrArray); err != nil { + return err + } + out[k] = schemaOrArray + } + } + return nil +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/BUILD index e61b8f824c5..90eb4120ecf 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/BUILD @@ -12,6 +12,8 @@ go_library( "strategy.go", ], deps = [ + "//vendor/github.com/go-openapi/validate:go_default_library", + "//vendor/k8s.io/apiextensions-apiserver/pkg/apiserver/validation:go_default_library", "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library", "//vendor/k8s.io/apimachinery/pkg/api/validation:go_default_library", "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/strategy.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/strategy.go index 6b97d07531a..18c6c2b7454 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/strategy.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/strategy.go @@ -19,9 +19,12 @@ package customresource import ( "fmt" + "github.com/go-openapi/validate" + "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/api/validation" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/fields" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime" @@ -30,6 +33,8 @@ import ( genericapirequest "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/apiserver/pkg/storage" "k8s.io/apiserver/pkg/storage/names" + + apiservervalidation "k8s.io/apiextensions-apiserver/pkg/apiserver/validation" ) type customResourceDefinitionStorageStrategy struct { @@ -40,7 +45,7 @@ type customResourceDefinitionStorageStrategy struct { validator customResourceValidator } -func NewStrategy(typer runtime.ObjectTyper, namespaceScoped bool, kind schema.GroupVersionKind) customResourceDefinitionStorageStrategy { +func NewStrategy(typer runtime.ObjectTyper, namespaceScoped bool, kind schema.GroupVersionKind, validator *validate.SchemaValidator) customResourceDefinitionStorageStrategy { return customResourceDefinitionStorageStrategy{ ObjectTyper: typer, NameGenerator: names.SimpleNameGenerator, @@ -48,6 +53,7 @@ func NewStrategy(typer runtime.ObjectTyper, namespaceScoped bool, kind schema.Gr validator: customResourceValidator{ namespaceScoped: namespaceScoped, kind: kind, + validator: validator, }, } } @@ -113,6 +119,7 @@ func (a customResourceDefinitionStorageStrategy) MatchCustomResourceDefinitionSt type customResourceValidator struct { namespaceScoped bool kind schema.GroupVersionKind + validator *validate.SchemaValidator } func (a customResourceValidator) Validate(ctx genericapirequest.Context, obj runtime.Object) field.ErrorList { @@ -131,6 +138,17 @@ func (a customResourceValidator) Validate(ctx genericapirequest.Context, obj run return field.ErrorList{field.Invalid(field.NewPath("apiVersion"), typeAccessor.GetKind(), fmt.Sprintf("must be %v", a.kind.Group+"/"+a.kind.Version))} } + customResourceObject, ok := obj.(*unstructured.Unstructured) + // this will never happen. + if !ok { + return field.ErrorList{field.Invalid(field.NewPath(""), customResourceObject, fmt.Sprintf("has type %T. Must be a pointer to an Unstructured type", customResourceObject))} + } + + customResource := customResourceObject.UnstructuredContent() + if err = apiservervalidation.ValidateCustomResource(customResource, a.validator); err != nil { + return field.ErrorList{field.Invalid(field.NewPath(""), customResource, err.Error())} + } + return validation.ValidateObjectMetaAccessor(accessor, a.namespaceScoped, validation.NameIsDNSSubdomain, field.NewPath("metadata")) } @@ -154,5 +172,16 @@ func (a customResourceValidator) ValidateUpdate(ctx genericapirequest.Context, o return field.ErrorList{field.Invalid(field.NewPath("apiVersion"), typeAccessor.GetKind(), fmt.Sprintf("must be %v", a.kind.Group+"/"+a.kind.Version))} } + customResourceObject, ok := obj.(*unstructured.Unstructured) + // this will never happen. + if !ok { + return field.ErrorList{field.Invalid(field.NewPath(""), customResourceObject, fmt.Sprintf("has type %T. Must be a pointer to an Unstructured type", customResourceObject))} + } + + customResource := customResourceObject.UnstructuredContent() + if err = apiservervalidation.ValidateCustomResource(customResource, a.validator); err != nil { + return field.ErrorList{field.Invalid(field.NewPath(""), customResource, err.Error())} + } + return validation.ValidateObjectMetaAccessorUpdate(objAccessor, oldAccessor, field.NewPath("metadata")) } From b1e16bff17a2e3f50ac3af9708559f5031dbc1c4 Mon Sep 17 00:00:00 2001 From: Nikhita Raghunath Date: Fri, 23 Jun 2017 05:04:32 +0530 Subject: [PATCH 4/6] Add integration tests Update test schema Add polling for TestCRValidationOnCRDUpdate Add tests for forbidden fields Enable featureGate for CustomResourceValidation --- .../test/integration/BUILD | 1 + .../test/integration/testserver/resources.go | 7 +- .../test/integration/validation_test.go | 372 +++++++++++++++++- 3 files changed, 378 insertions(+), 2 deletions(-) diff --git a/staging/src/k8s.io/apiextensions-apiserver/test/integration/BUILD b/staging/src/k8s.io/apiextensions-apiserver/test/integration/BUILD index 482ab94a39e..bea580200d5 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/test/integration/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/test/integration/BUILD @@ -32,6 +32,7 @@ go_test( "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library", "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library", "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library", + "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library", "//vendor/k8s.io/client-go/dynamic:go_default_library", ], ) diff --git a/staging/src/k8s.io/apiextensions-apiserver/test/integration/testserver/resources.go b/staging/src/k8s.io/apiextensions-apiserver/test/integration/testserver/resources.go index a0efcb43da7..f80ad8bf6e8 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/test/integration/testserver/resources.go +++ b/staging/src/k8s.io/apiextensions-apiserver/test/integration/testserver/resources.go @@ -213,7 +213,7 @@ func checkForWatchCachePrimed(crd *apiextensionsv1beta1.CustomResourceDefinition return err } - instanceName := "foo" + instanceName := "setup-instance" instance := &unstructured.Unstructured{ Object: map[string]interface{}{ "apiVersion": crd.Spec.Group + "/" + crd.Spec.Version, @@ -222,6 +222,11 @@ func checkForWatchCachePrimed(crd *apiextensionsv1beta1.CustomResourceDefinition "namespace": ns, "name": instanceName, }, + "alpha": "foo_123", + "beta": 10, + "gamma": "bar", + "delta": "hello", + "epsilon": "foobar", }, } if _, err := resourceClient.Create(instance); err != nil { diff --git a/staging/src/k8s.io/apiextensions-apiserver/test/integration/validation_test.go b/staging/src/k8s.io/apiextensions-apiserver/test/integration/validation_test.go index 69ccb58aa4a..3c771ef1825 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/test/integration/validation_test.go +++ b/staging/src/k8s.io/apiextensions-apiserver/test/integration/validation_test.go @@ -19,10 +19,15 @@ package integration import ( "strings" "testing" + "time" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/util/wait" + utilfeature "k8s.io/apiserver/pkg/util/feature" apiextensionsv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" "k8s.io/apiextensions-apiserver/test/integration/testserver" - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" ) func TestForProperValidationErrors(t *testing.T) { @@ -79,3 +84,368 @@ func TestForProperValidationErrors(t *testing.T) { } } } + +func newNoxuValidationCRD(scope apiextensionsv1beta1.ResourceScope) *apiextensionsv1beta1.CustomResourceDefinition { + return &apiextensionsv1beta1.CustomResourceDefinition{ + ObjectMeta: metav1.ObjectMeta{Name: "noxus.mygroup.example.com"}, + Spec: apiextensionsv1beta1.CustomResourceDefinitionSpec{ + Group: "mygroup.example.com", + Version: "v1beta1", + Names: apiextensionsv1beta1.CustomResourceDefinitionNames{ + Plural: "noxus", + Singular: "nonenglishnoxu", + Kind: "WishIHadChosenNoxu", + ShortNames: []string{"foo", "bar", "abc", "def"}, + ListKind: "NoxuItemList", + }, + Scope: apiextensionsv1beta1.NamespaceScoped, + Validation: &apiextensionsv1beta1.CustomResourceValidation{ + OpenAPIV3Schema: &apiextensionsv1beta1.JSONSchemaProps{ + Required: []string{"alpha", "beta"}, + AdditionalProperties: &apiextensionsv1beta1.JSONSchemaPropsOrBool{ + Allows: true, + }, + Properties: map[string]apiextensionsv1beta1.JSONSchemaProps{ + "alpha": { + Description: "Alpha is an alphanumeric string with underscores", + Type: "string", + Pattern: "^[a-zA-Z0-9_]*$", + }, + "beta": { + Description: "Minimum value of beta is 10", + Type: "number", + Minimum: float64Ptr(10), + }, + "gamma": { + Description: "Gamma is restricted to foo, bar and baz", + Type: "string", + Enum: []apiextensionsv1beta1.JSON{ + { + Raw: []byte(`"foo"`), + }, + { + Raw: []byte(`"bar"`), + }, + { + Raw: []byte(`"baz"`), + }, + }, + }, + "delta": { + Description: "Delta is a string with a maximum length of 5 or a number with a minimum value of 0", + AnyOf: []apiextensionsv1beta1.JSONSchemaProps{ + { + Type: "string", + MaxLength: int64Ptr(5), + }, + { + Type: "number", + Minimum: float64Ptr(0), + }, + }, + }, + }, + }, + }, + }, + } +} + +func newNoxuValidationInstance(namespace, name string) *unstructured.Unstructured { + return &unstructured.Unstructured{ + Object: map[string]interface{}{ + "apiVersion": "mygroup.example.com/v1beta1", + "kind": "WishIHadChosenNoxu", + "metadata": map[string]interface{}{ + "namespace": namespace, + "name": name, + }, + "alpha": "foo_123", + "beta": 10, + "gamma": "bar", + "delta": "hello", + }, + } +} + +func TestCustomResourceValidation(t *testing.T) { + stopCh, apiExtensionClient, clientPool, err := testserver.StartDefaultServer() + if err != nil { + t.Fatal(err) + } + defer close(stopCh) + + // enable alpha feature CustomResourceValidation + err = utilfeature.DefaultFeatureGate.Set("CustomResourceValidation=true") + if err != nil { + t.Errorf("failed to enable feature gate for CustomResourceValidation: %v", err) + } + + noxuDefinition := newNoxuValidationCRD(apiextensionsv1beta1.NamespaceScoped) + noxuVersionClient, err := testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err != nil { + t.Fatal(err) + } + + ns := "not-the-default" + noxuResourceClient := NewNamespacedCustomResourceClient(ns, noxuVersionClient, noxuDefinition) + _, err = instantiateCustomResource(t, newNoxuValidationInstance(ns, "foo"), noxuResourceClient, noxuDefinition) + if err != nil { + t.Fatalf("unable to create noxu instance: %v", err) + } +} + +func TestCustomResourceUpdateValidation(t *testing.T) { + stopCh, apiExtensionClient, clientPool, err := testserver.StartDefaultServer() + if err != nil { + t.Fatal(err) + } + defer close(stopCh) + + // enable alpha feature CustomResourceValidation + err = utilfeature.DefaultFeatureGate.Set("CustomResourceValidation=true") + if err != nil { + t.Errorf("failed to enable feature gate for CustomResourceValidation: %v", err) + } + + noxuDefinition := newNoxuValidationCRD(apiextensionsv1beta1.NamespaceScoped) + noxuVersionClient, err := testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err != nil { + t.Fatal(err) + } + + ns := "not-the-default" + noxuResourceClient := NewNamespacedCustomResourceClient(ns, noxuVersionClient, noxuDefinition) + _, err = instantiateCustomResource(t, newNoxuValidationInstance(ns, "foo"), noxuResourceClient, noxuDefinition) + if err != nil { + t.Fatalf("unable to create noxu instance: %v", err) + } + + gottenNoxuInstance, err := noxuResourceClient.Get("foo", metav1.GetOptions{}) + if err != nil { + t.Fatal(err) + } + + // invalidate the instance + gottenNoxuInstance.Object = map[string]interface{}{ + "apiVersion": "mygroup.example.com/v1beta1", + "kind": "WishIHadChosenNoxu", + "metadata": map[string]interface{}{ + "namespace": "not-the-default", + "name": "foo", + }, + "gamma": "bar", + "delta": "hello", + } + + _, err = noxuResourceClient.Update(gottenNoxuInstance) + if err == nil { + t.Fatalf("unexpected non-error: alpha and beta should be present while updating %v", gottenNoxuInstance) + } +} + +func TestCustomResourceValidationErrors(t *testing.T) { + stopCh, apiExtensionClient, clientPool, err := testserver.StartDefaultServer() + if err != nil { + t.Fatal(err) + } + defer close(stopCh) + + // enable alpha feature CustomResourceValidation + err = utilfeature.DefaultFeatureGate.Set("CustomResourceValidation=true") + if err != nil { + t.Errorf("failed to enable feature gate for CustomResourceValidation: %v", err) + } + + noxuDefinition := newNoxuValidationCRD(apiextensionsv1beta1.NamespaceScoped) + noxuVersionClient, err := testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err != nil { + t.Fatal(err) + } + + ns := "not-the-default" + noxuResourceClient := NewNamespacedCustomResourceClient(ns, noxuVersionClient, noxuDefinition) + + tests := []struct { + name string + instanceFn func() *unstructured.Unstructured + expectedError string + }{ + { + name: "bad alpha", + instanceFn: func() *unstructured.Unstructured { + instance := newNoxuValidationInstance(ns, "foo") + instance.Object["alpha"] = "foo_123!" + return instance + }, + expectedError: "alpha in body should match '^[a-zA-Z0-9_]*$'", + }, + { + name: "bad beta", + instanceFn: func() *unstructured.Unstructured { + instance := newNoxuValidationInstance(ns, "foo") + instance.Object["beta"] = 5 + return instance + }, + expectedError: "beta in body should be greater than or equal to 10", + }, + { + name: "bad gamma", + instanceFn: func() *unstructured.Unstructured { + instance := newNoxuValidationInstance(ns, "foo") + instance.Object["gamma"] = "qux" + return instance + }, + expectedError: "gamma in body should be one of [foo bar baz]", + }, + { + name: "bad delta", + instanceFn: func() *unstructured.Unstructured { + instance := newNoxuValidationInstance(ns, "foo") + instance.Object["delta"] = "foobarbaz" + return instance + }, + expectedError: "must validate at least one schema (anyOf)\ndelta in body should be at most 5 chars long", + }, + { + name: "absent alpha and beta", + instanceFn: func() *unstructured.Unstructured { + instance := newNoxuValidationInstance(ns, "foo") + instance.Object = map[string]interface{}{ + "apiVersion": "mygroup.example.com/v1beta1", + "kind": "WishIHadChosenNoxu", + "metadata": map[string]interface{}{ + "namespace": "not-the-default", + "name": "foo", + }, + "gamma": "bar", + "delta": "hello", + } + return instance + }, + expectedError: ".alpha in body is required\n.beta in body is required", + }, + } + + for _, tc := range tests { + _, err := noxuResourceClient.Create(tc.instanceFn()) + if err == nil { + t.Errorf("%v: expected %v", tc.name, tc.expectedError) + continue + } + // this only works when status errors contain the expect kind and version, so this effectively tests serializations too + if !strings.Contains(err.Error(), tc.expectedError) { + t.Errorf("%v: expected %v, got %v", tc.name, tc.expectedError, err) + continue + } + } +} + +func TestCRValidationOnCRDUpdate(t *testing.T) { + stopCh, apiExtensionClient, clientPool, err := testserver.StartDefaultServer() + if err != nil { + t.Fatal(err) + } + defer close(stopCh) + + // enable alpha feature CustomResourceValidation + err = utilfeature.DefaultFeatureGate.Set("CustomResourceValidation=true") + if err != nil { + t.Errorf("failed to enable feature gate for CustomResourceValidation: %v", err) + } + + noxuDefinition := newNoxuValidationCRD(apiextensionsv1beta1.NamespaceScoped) + + // set stricter schema + noxuDefinition.Spec.Validation.OpenAPIV3Schema.Required = []string{"alpha", "beta", "epsilon"} + + noxuVersionClient, err := testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err != nil { + t.Fatal(err) + } + ns := "not-the-default" + noxuResourceClient := NewNamespacedCustomResourceClient(ns, noxuVersionClient, noxuDefinition) + + // CR is rejected + _, err = instantiateCustomResource(t, newNoxuValidationInstance(ns, "foo"), noxuResourceClient, noxuDefinition) + if err == nil { + t.Fatalf("unexpected non-error: CR should be rejected") + } + + gottenCRD, err := apiExtensionClient.ApiextensionsV1beta1().CustomResourceDefinitions().Get("noxus.mygroup.example.com", metav1.GetOptions{}) + if err != nil { + t.Fatal(err) + } + + // update the CRD to a less stricter schema + gottenCRD.Spec.Validation.OpenAPIV3Schema.Required = []string{"alpha", "beta"} + + updatedCRD, err := apiExtensionClient.ApiextensionsV1beta1().CustomResourceDefinitions().Update(gottenCRD) + if err != nil { + t.Fatal(err) + } + + // CR is now accepted + err = wait.Poll(500*time.Millisecond, wait.ForeverTestTimeout, func() (bool, error) { + _, err = instantiateCustomResource(t, newNoxuValidationInstance(ns, "foo"), noxuResourceClient, updatedCRD) + if err != nil { + return false, err + } + return true, nil + }) + if err != nil { + t.Fatal(err) + } +} + +func TestForbiddenFieldsInSchema(t *testing.T) { + stopCh, apiExtensionClient, clientPool, err := testserver.StartDefaultServer() + if err != nil { + t.Fatal(err) + } + defer close(stopCh) + + // enable alpha feature CustomResourceValidation + err = utilfeature.DefaultFeatureGate.Set("CustomResourceValidation=true") + if err != nil { + t.Errorf("failed to enable feature gate for CustomResourceValidation: %v", err) + } + + noxuDefinition := newNoxuValidationCRD(apiextensionsv1beta1.NamespaceScoped) + noxuDefinition.Spec.Validation.OpenAPIV3Schema.AdditionalProperties.Allows = false + + _, err = testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err == nil { + t.Fatalf("unexpected non-error: additionalProperties cannot be set to false") + } + + noxuDefinition.Spec.Validation.OpenAPIV3Schema.Properties["zeta"] = apiextensionsv1beta1.JSONSchemaProps{ + Type: "array", + UniqueItems: true, + } + noxuDefinition.Spec.Validation.OpenAPIV3Schema.AdditionalProperties.Allows = true + + _, err = testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err == nil { + t.Fatalf("unexpected non-error: uniqueItems cannot be set to true") + } + + noxuDefinition.Spec.Validation.OpenAPIV3Schema.Properties["zeta"] = apiextensionsv1beta1.JSONSchemaProps{ + Type: "array", + UniqueItems: false, + } + + _, err = testserver.CreateNewCustomResourceDefinition(noxuDefinition, apiExtensionClient, clientPool) + if err != nil { + t.Fatal(err) + } + +} + +func float64Ptr(f float64) *float64 { + return &f +} + +func int64Ptr(f int64) *int64 { + return &f +} From ccb8554dd8098da88cbefb9c282aee735c5f216d Mon Sep 17 00:00:00 2001 From: Nikhita Raghunath Date: Fri, 11 Aug 2017 16:54:52 +0530 Subject: [PATCH 5/6] Update godeps --- .../Godeps/Godeps.json | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json b/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json index 329d7254238..722936ad9ae 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json +++ b/staging/src/k8s.io/apiextensions-apiserver/Godeps/Godeps.json @@ -22,6 +22,10 @@ "ImportPath": "github.com/PuerkitoBio/urlesc", "Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e" }, + { + "ImportPath": "github.com/asaskevich/govalidator", + "Rev": "593d64559f7600f29581a3ee42177f5dbded27a9" + }, { "ImportPath": "github.com/beorn7/perks/quantile", "Rev": "3ac7bf7a47d159a033b107610db8a1b6575507a4" @@ -110,6 +114,14 @@ "ImportPath": "github.com/ghodss/yaml", "Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee" }, + { + "ImportPath": "github.com/go-openapi/analysis", + "Rev": "b44dc874b601d9e4e2f6e19140e794ba24bead3b" + }, + { + "ImportPath": "github.com/go-openapi/errors", + "Rev": "d24ebc2075bad502fac3a8ae27aa6dd58e1952dc" + }, { "ImportPath": "github.com/go-openapi/jsonpointer", "Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98" @@ -118,14 +130,30 @@ "ImportPath": "github.com/go-openapi/jsonreference", "Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272" }, + { + "ImportPath": "github.com/go-openapi/loads", + "Rev": "18441dfa706d924a39a030ee2c3b1d8d81917b38" + }, + { + "ImportPath": "github.com/go-openapi/runtime", + "Rev": "11e322eeecc1032d5a0a96c566ed53f2b5c26e22" + }, { "ImportPath": "github.com/go-openapi/spec", "Rev": "6aced65f8501fe1217321abf0749d354824ba2ff" }, + { + "ImportPath": "github.com/go-openapi/strfmt", + "Rev": "d65c7fdb29eca313476e529628176fe17e58c488" + }, { "ImportPath": "github.com/go-openapi/swag", "Rev": "1d0bd113de87027671077d3c71eb3ac5d7dbba72" }, + { + "ImportPath": "github.com/go-openapi/validate", + "Rev": "deaf2c9013bc1a7f4c774662259a506ba874d80f" + }, { "ImportPath": "github.com/gogo/protobuf/proto", "Rev": "c0656edd0d9eab7c66d1eb0c568f9039345796f7" From 6ba1523a8e36c3121a9e08bfac7b4f342bb8ccb3 Mon Sep 17 00:00:00 2001 From: Nikhita Raghunath Date: Mon, 14 Aug 2017 21:44:02 +0530 Subject: [PATCH 6/6] Add feature gate for CustomResourceValidation update feature gates for generic apiserver Add apiextensions-apiserver features to golint_failures Ignore alpha feature if gate is disabled --- hack/.golint_failures | 1 + pkg/features/BUILD | 1 + pkg/features/kube_features.go | 21 ++++----- .../src/k8s.io/apiextensions-apiserver/BUILD | 1 + .../pkg/features/BUILD | 25 ++++++++++ .../pkg/features/kube_features.go | 46 +++++++++++++++++++ .../registry/customresourcedefinition/BUILD | 2 + .../customresourcedefinition/strategy.go | 12 +++++ .../apiserver/pkg/features/kube_features.go | 4 +- 9 files changed, 100 insertions(+), 13 deletions(-) create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/features/BUILD create mode 100644 staging/src/k8s.io/apiextensions-apiserver/pkg/features/kube_features.go diff --git a/hack/.golint_failures b/hack/.golint_failures index 32330dca2e0..3098d5667b3 100644 --- a/hack/.golint_failures +++ b/hack/.golint_failures @@ -548,6 +548,7 @@ staging/src/k8s.io/apiextensions-apiserver/pkg/client/informers/internalversion/ staging/src/k8s.io/apiextensions-apiserver/pkg/cmd/server staging/src/k8s.io/apiextensions-apiserver/pkg/controller/finalizer staging/src/k8s.io/apiextensions-apiserver/pkg/controller/status +staging/src/k8s.io/apiextensions-apiserver/pkg/features staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition staging/src/k8s.io/apiextensions-apiserver/test/integration/testserver diff --git a/pkg/features/BUILD b/pkg/features/BUILD index 30bf7b14ecb..dac4e2e9ca9 100644 --- a/pkg/features/BUILD +++ b/pkg/features/BUILD @@ -9,6 +9,7 @@ go_library( name = "go_default_library", srcs = ["kube_features.go"], deps = [ + "//vendor/k8s.io/apiextensions-apiserver/pkg/features:go_default_library", "//vendor/k8s.io/apiserver/pkg/features:go_default_library", "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library", ], diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index 98713fe35ab..b7bc05ff3e1 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -17,6 +17,7 @@ limitations under the License. package features import ( + apiextensionsfeatures "k8s.io/apiextensions-apiserver/pkg/features" genericfeatures "k8s.io/apiserver/pkg/features" utilfeature "k8s.io/apiserver/pkg/util/feature" ) @@ -44,13 +45,6 @@ const ( // alpha: v1.4 DynamicKubeletConfig utilfeature.Feature = "DynamicKubeletConfig" - // owner: tallclair - // alpha: v1.5 - // - // StreamingProxyRedirects controls whether the apiserver should intercept (and follow) - // redirects from the backend (Kubelet) for streaming requests (exec/attach/port-forward). - StreamingProxyRedirects utilfeature.Feature = genericfeatures.StreamingProxyRedirects - // owner: @pweil- // alpha: v1.5 // @@ -158,11 +152,16 @@ var defaultKubernetesFeatureGates = map[utilfeature.Feature]utilfeature.FeatureS DebugContainers: {Default: false, PreRelease: utilfeature.Alpha}, PodPriority: {Default: false, PreRelease: utilfeature.Alpha}, EnableEquivalenceClassCache: {Default: false, PreRelease: utilfeature.Alpha}, + TaintNodesByCondition: {Default: false, PreRelease: utilfeature.Alpha}, // inherited features from generic apiserver, relisted here to get a conflict if it is changed // unintentionally on either side: - StreamingProxyRedirects: {Default: true, PreRelease: utilfeature.Beta}, - genericfeatures.AdvancedAuditing: {Default: false, PreRelease: utilfeature.Alpha}, - TaintNodesByCondition: {Default: false, PreRelease: utilfeature.Alpha}, - genericfeatures.Initializers: {Default: false, PreRelease: utilfeature.Alpha}, + genericfeatures.StreamingProxyRedirects: {Default: true, PreRelease: utilfeature.Beta}, + genericfeatures.AdvancedAuditing: {Default: false, PreRelease: utilfeature.Alpha}, + genericfeatures.APIResponseCompression: {Default: false, PreRelease: utilfeature.Alpha}, + genericfeatures.Initializers: {Default: false, PreRelease: utilfeature.Alpha}, + + // inherited features from apiextensions-apiserver, relisted here to get a conflict if it is changed + // unintentionally on either side: + apiextensionsfeatures.CustomResourceValidation: {Default: false, PreRelease: utilfeature.Alpha}, } diff --git a/staging/src/k8s.io/apiextensions-apiserver/BUILD b/staging/src/k8s.io/apiextensions-apiserver/BUILD index b52477d47a1..90eddd2ef56 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/BUILD @@ -45,6 +45,7 @@ filegroup( "//staging/src/k8s.io/apiextensions-apiserver/pkg/cmd/server:all-srcs", "//staging/src/k8s.io/apiextensions-apiserver/pkg/controller/finalizer:all-srcs", "//staging/src/k8s.io/apiextensions-apiserver/pkg/controller/status:all-srcs", + "//staging/src/k8s.io/apiextensions-apiserver/pkg/features:all-srcs", "//staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource:all-srcs", "//staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition:all-srcs", "//staging/src/k8s.io/apiextensions-apiserver/test/integration:all-srcs", diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/features/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/features/BUILD new file mode 100644 index 00000000000..3b415effc45 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/features/BUILD @@ -0,0 +1,25 @@ +package(default_visibility = ["//visibility:public"]) + +load( + "@io_bazel_rules_go//go:def.bzl", + "go_library", +) + +go_library( + name = "go_default_library", + srcs = ["kube_features.go"], + deps = ["//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library"], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], +) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/features/kube_features.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/features/kube_features.go new file mode 100644 index 00000000000..fa78ce6ab51 --- /dev/null +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/features/kube_features.go @@ -0,0 +1,46 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package features + +import ( + utilfeature "k8s.io/apiserver/pkg/util/feature" +) + +const ( + // Every feature gate should add method here following this template: + // + // // owner: @username + // // alpha: v1.4 + // MyFeature() bool + + // owner: @sttts, @nikhita + // alpha: v1.8 + // + // CustomResourceValidation is a list of validation methods for CustomResources + CustomResourceValidation utilfeature.Feature = "CustomResourceValidation" +) + +func init() { + utilfeature.DefaultFeatureGate.Add(defaultKubernetesFeatureGates) +} + +// defaultKubernetesFeatureGates consists of all known Kubernetes-specific feature keys. +// To add a new feature, define a key for it above and add it here. The features will be +// available throughout Kubernetes binaries. +var defaultKubernetesFeatureGates = map[utilfeature.Feature]utilfeature.FeatureSpec{ + CustomResourceValidation: {Default: false, PreRelease: utilfeature.Alpha}, +} diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/BUILD b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/BUILD index 42e88f9887f..5a433a3e0ab 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/BUILD +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/BUILD @@ -14,6 +14,7 @@ go_library( deps = [ "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions:go_default_library", "//vendor/k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation:go_default_library", + "//vendor/k8s.io/apiextensions-apiserver/pkg/features:go_default_library", "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library", "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library", "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", @@ -28,6 +29,7 @@ go_library( "//vendor/k8s.io/apiserver/pkg/storage:go_default_library", "//vendor/k8s.io/apiserver/pkg/storage/errors:go_default_library", "//vendor/k8s.io/apiserver/pkg/storage/names:go_default_library", + "//vendor/k8s.io/apiserver/pkg/util/feature:go_default_library", ], ) diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/strategy.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/strategy.go index b6314b0c5c8..849cd6f8ea7 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/strategy.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/strategy.go @@ -28,9 +28,11 @@ import ( "k8s.io/apiserver/pkg/registry/generic" "k8s.io/apiserver/pkg/storage" "k8s.io/apiserver/pkg/storage/names" + utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions" "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/validation" + apiextensionsfeatures "k8s.io/apiextensions-apiserver/pkg/features" ) type strategy struct { @@ -50,6 +52,11 @@ func (strategy) PrepareForCreate(ctx genericapirequest.Context, obj runtime.Obje crd := obj.(*apiextensions.CustomResourceDefinition) crd.Status = apiextensions.CustomResourceDefinitionStatus{} crd.Generation = 1 + + // if the feature gate is disabled, drop the feature. + if !utilfeature.DefaultFeatureGate.Enabled(apiextensionsfeatures.CustomResourceValidation) { + crd.Spec.Validation = nil + } } func (strategy) PrepareForUpdate(ctx genericapirequest.Context, obj, old runtime.Object) { @@ -68,6 +75,11 @@ func (strategy) PrepareForUpdate(ctx genericapirequest.Context, obj, old runtime if !apiequality.Semantic.DeepEqual(oldCRD.Spec, newCRD.Spec) { newCRD.Generation = oldCRD.Generation + 1 } + + if !utilfeature.DefaultFeatureGate.Enabled(apiextensionsfeatures.CustomResourceValidation) { + newCRD.Spec.Validation = nil + oldCRD.Spec.Validation = nil + } } func (strategy) Validate(ctx genericapirequest.Context, obj runtime.Object) field.ErrorList { diff --git a/staging/src/k8s.io/apiserver/pkg/features/kube_features.go b/staging/src/k8s.io/apiserver/pkg/features/kube_features.go index 8e2478aab8e..f874cd90740 100644 --- a/staging/src/k8s.io/apiserver/pkg/features/kube_features.go +++ b/staging/src/k8s.io/apiserver/pkg/features/kube_features.go @@ -27,14 +27,14 @@ const ( // // alpha: v1.4 // MyFeature() bool - // owner: tallclair + // owner: @tallclair // alpha: v1.5 // // StreamingProxyRedirects controls whether the apiserver should intercept (and follow) // redirects from the backend (Kubelet) for streaming requests (exec/attach/port-forward). StreamingProxyRedirects utilfeature.Feature = "StreamingProxyRedirects" - // owner: tallclair + // owner: @tallclair // alpha: v1.7 // // AdvancedAuditing enables a much more general API auditing pipeline, which includes support for