validator.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: validator.proto

package amp_validator

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// These two fields specify that values from one AttrSpec refer to values from
// another AttrSpec elsewhere on the page; validator will verify the
// references are not "dangling". These references may appear before or after
// their referents.
//
// For example, in the "id" AttrSpec in the "template" TagSpec, we have:
//   add_value_to_set: TEMPLATE_IDS
// and in any "template" AttrSpec, we have:
//   value_oneof_set: TEMPLATE_IDS
// NEXT AVAILABLE TAG: 3
type AttrSpec_ValueSet int32

const (
	AttrSpec_UNKNOWN_VALUESET AttrSpec_ValueSet = 0
	AttrSpec_TEMPLATE_IDS     AttrSpec_ValueSet = 1
	AttrSpec_AMP_SCRIPT_IDS   AttrSpec_ValueSet = 2
)

var AttrSpec_ValueSet_name = map[int32]string{
	0: "UNKNOWN_VALUESET",
	1: "TEMPLATE_IDS",
	2: "AMP_SCRIPT_IDS",
}

var AttrSpec_ValueSet_value = map[string]int32{
	"UNKNOWN_VALUESET": 0,
	"TEMPLATE_IDS":     1,
	"AMP_SCRIPT_IDS":   2,
}

func (x AttrSpec_ValueSet) Enum() *AttrSpec_ValueSet {
	p := new(AttrSpec_ValueSet)
	*p = x
	return p
}

func (x AttrSpec_ValueSet) String() string {
	return proto.EnumName(AttrSpec_ValueSet_name, int32(x))
}

func (x *AttrSpec_ValueSet) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AttrSpec_ValueSet_value, data, "AttrSpec_ValueSet")
	if err != nil {
		return err
	}
	*x = AttrSpec_ValueSet(value)
	return nil
}

func (AttrSpec_ValueSet) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{5, 0}
}

type AttrSpec_DispatchKeyType int32

const (
	// Indicates that the attribute does not form a dispatch key.
	AttrSpec_NONE_DISPATCH AttrSpec_DispatchKeyType = 0
	// Indicates that the name of the attribute alone forms a dispatch key.
	AttrSpec_NAME_DISPATCH AttrSpec_DispatchKeyType = 1
	// Indicates that the name + value of the attribute forms a dispatch key.
	AttrSpec_NAME_VALUE_DISPATCH AttrSpec_DispatchKeyType = 2
	// Indicates that the name + value + mandatory parent forms a dispatch key.
	AttrSpec_NAME_VALUE_PARENT_DISPATCH AttrSpec_DispatchKeyType = 3
)

var AttrSpec_DispatchKeyType_name = map[int32]string{
	0: "NONE_DISPATCH",
	1: "NAME_DISPATCH",
	2: "NAME_VALUE_DISPATCH",
	3: "NAME_VALUE_PARENT_DISPATCH",
}

var AttrSpec_DispatchKeyType_value = map[string]int32{
	"NONE_DISPATCH":              0,
	"NAME_DISPATCH":              1,
	"NAME_VALUE_DISPATCH":        2,
	"NAME_VALUE_PARENT_DISPATCH": 3,
}

func (x AttrSpec_DispatchKeyType) Enum() *AttrSpec_DispatchKeyType {
	p := new(AttrSpec_DispatchKeyType)
	*p = x
	return p
}

func (x AttrSpec_DispatchKeyType) String() string {
	return proto.EnumName(AttrSpec_DispatchKeyType_name, int32(x))
}

func (x *AttrSpec_DispatchKeyType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AttrSpec_DispatchKeyType_value, data, "AttrSpec_DispatchKeyType")
	if err != nil {
		return err
	}
	*x = AttrSpec_DispatchKeyType(value)
	return nil
}

func (AttrSpec_DispatchKeyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{5, 1}
}

// NEXT AVAILABLE TAG: 10
type AmpLayout_Layout int32

const (
	AmpLayout_CONTAINER    AmpLayout_Layout = 5
	AmpLayout_FILL         AmpLayout_Layout = 6
	AmpLayout_FIXED        AmpLayout_Layout = 2
	AmpLayout_FIXED_HEIGHT AmpLayout_Layout = 3
	AmpLayout_FLEX_ITEM    AmpLayout_Layout = 7
	AmpLayout_FLUID        AmpLayout_Layout = 8
	AmpLayout_INTRINSIC    AmpLayout_Layout = 9
	AmpLayout_NODISPLAY    AmpLayout_Layout = 1
	AmpLayout_RESPONSIVE   AmpLayout_Layout = 4
	AmpLayout_UNKNOWN      AmpLayout_Layout = 0
)

var AmpLayout_Layout_name = map[int32]string{
	5: "CONTAINER",
	6: "FILL",
	2: "FIXED",
	3: "FIXED_HEIGHT",
	7: "FLEX_ITEM",
	8: "FLUID",
	9: "INTRINSIC",
	1: "NODISPLAY",
	4: "RESPONSIVE",
	0: "UNKNOWN",
}

var AmpLayout_Layout_value = map[string]int32{
	"CONTAINER":    5,
	"FILL":         6,
	"FIXED":        2,
	"FIXED_HEIGHT": 3,
	"FLEX_ITEM":    7,
	"FLUID":        8,
	"INTRINSIC":    9,
	"NODISPLAY":    1,
	"RESPONSIVE":   4,
	"UNKNOWN":      0,
}

func (x AmpLayout_Layout) Enum() *AmpLayout_Layout {
	p := new(AmpLayout_Layout)
	*p = x
	return p
}

func (x AmpLayout_Layout) String() string {
	return proto.EnumName(AmpLayout_Layout_name, int32(x))
}

func (x *AmpLayout_Layout) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AmpLayout_Layout_value, data, "AmpLayout_Layout")
	if err != nil {
		return err
	}
	*x = AmpLayout_Layout(value)
	return nil
}

func (AmpLayout_Layout) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{15, 0}
}

// NEXT AVAILABLE TAG: 2
type AncestorMarker_Marker int32

const (
	AncestorMarker_UNKNOWN AncestorMarker_Marker = 0
	// Set by <amp-sidebar> tags to allow autoscroll attributes on descendants.
	// See https://github.com/ampproject/amphtml/pull/20524 for more context.
	AncestorMarker_AUTOSCROLL AncestorMarker_Marker = 1
)

var AncestorMarker_Marker_name = map[int32]string{
	0: "UNKNOWN",
	1: "AUTOSCROLL",
}

var AncestorMarker_Marker_value = map[string]int32{
	"UNKNOWN":    0,
	"AUTOSCROLL": 1,
}

func (x AncestorMarker_Marker) Enum() *AncestorMarker_Marker {
	p := new(AncestorMarker_Marker)
	*p = x
	return p
}

func (x AncestorMarker_Marker) String() string {
	return proto.EnumName(AncestorMarker_Marker_name, int32(x))
}

func (x *AncestorMarker_Marker) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AncestorMarker_Marker_value, data, "AncestorMarker_Marker")
	if err != nil {
		return err
	}
	*x = AncestorMarker_Marker(value)
	return nil
}

func (AncestorMarker_Marker) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{16, 0}
}

// Most extensions are custom-elements. For custom-template extensions, this
// value needs to be set true. E.g: amp-mustache.
// NEXT AVAILABLE TAG: 4
type ExtensionSpec_ExtensionType int32

const (
	ExtensionSpec_UNKNOWN         ExtensionSpec_ExtensionType = 0
	ExtensionSpec_CUSTOM_ELEMENT  ExtensionSpec_ExtensionType = 1
	ExtensionSpec_CUSTOM_TEMPLATE ExtensionSpec_ExtensionType = 2
	ExtensionSpec_HOST_SERVICE    ExtensionSpec_ExtensionType = 3
)

var ExtensionSpec_ExtensionType_name = map[int32]string{
	0: "UNKNOWN",
	1: "CUSTOM_ELEMENT",
	2: "CUSTOM_TEMPLATE",
	3: "HOST_SERVICE",
}

var ExtensionSpec_ExtensionType_value = map[string]int32{
	"UNKNOWN":         0,
	"CUSTOM_ELEMENT":  1,
	"CUSTOM_TEMPLATE": 2,
	"HOST_SERVICE":    3,
}

func (x ExtensionSpec_ExtensionType) Enum() *ExtensionSpec_ExtensionType {
	p := new(ExtensionSpec_ExtensionType)
	*p = x
	return p
}

func (x ExtensionSpec_ExtensionType) String() string {
	return proto.EnumName(ExtensionSpec_ExtensionType_name, int32(x))
}

func (x *ExtensionSpec_ExtensionType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExtensionSpec_ExtensionType_value, data, "ExtensionSpec_ExtensionType")
	if err != nil {
		return err
	}
	*x = ExtensionSpec_ExtensionType(value)
	return nil
}

func (ExtensionSpec_ExtensionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{19, 0}
}

// TagSpec.requires_extension will be set to the new extension's name on one
// or more TagSpecs that require that extension. This typically creates 2
// validation requirements:
//  1) If a tag is on the page whose TagSpec has the requires_extension
//     field set, but that extension is not present, this is an error.
//     (Usage requires extension).
//  2) If an extension is on the page, but no tags indicating usage of that
//     extension via the required_extension field are on the page, this is an
//     error. (Extension requires usage).
//
// The second requirement (extension requires usage) has a few exceptions:
//   1) For older extensions, implemented before these tagspec rules, we
//      do not want to introduce a breaking change, so we exempt these
//      extensions from the usage requirement. New extensions must use ERROR.
//   2) Some extensions, such as `amp-dynamic-css-classes`, do not have any
//      associated tag in the document indicating usage. These extensions do
//      not trigger warnings or errors.
// NEXT AVAILABLE TAG: 4
type ExtensionSpec_ExtensionUsageRequirement int32

const (
	ExtensionSpec_ERROR ExtensionSpec_ExtensionUsageRequirement = 1
	// Exception for exempted extensions. #1 above.
	ExtensionSpec_EXEMPTED ExtensionSpec_ExtensionUsageRequirement = 2
	// Exception for extensions with no usage-indicating tag. #2 above.
	ExtensionSpec_NONE ExtensionSpec_ExtensionUsageRequirement = 3
)

var ExtensionSpec_ExtensionUsageRequirement_name = map[int32]string{
	1: "ERROR",
	2: "EXEMPTED",
	3: "NONE",
}

var ExtensionSpec_ExtensionUsageRequirement_value = map[string]int32{
	"ERROR":    1,
	"EXEMPTED": 2,
	"NONE":     3,
}

func (x ExtensionSpec_ExtensionUsageRequirement) Enum() *ExtensionSpec_ExtensionUsageRequirement {
	p := new(ExtensionSpec_ExtensionUsageRequirement)
	*p = x
	return p
}

func (x ExtensionSpec_ExtensionUsageRequirement) String() string {
	return proto.EnumName(ExtensionSpec_ExtensionUsageRequirement_name, int32(x))
}

func (x *ExtensionSpec_ExtensionUsageRequirement) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExtensionSpec_ExtensionUsageRequirement_value, data, "ExtensionSpec_ExtensionUsageRequirement")
	if err != nil {
		return err
	}
	*x = ExtensionSpec_ExtensionUsageRequirement(value)
	return nil
}

func (ExtensionSpec_ExtensionUsageRequirement) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{19, 1}
}

// NEXT AVAILABLE TAG: 6
type HtmlFormat_Code int32

const (
	HtmlFormat_UNKNOWN_CODE HtmlFormat_Code = 0
	HtmlFormat_AMP          HtmlFormat_Code = 1
	HtmlFormat_AMP4ADS      HtmlFormat_Code = 2
	HtmlFormat_AMP4EMAIL    HtmlFormat_Code = 3
	HtmlFormat_EXPERIMENTAL HtmlFormat_Code = 4
)

var HtmlFormat_Code_name = map[int32]string{
	0: "UNKNOWN_CODE",
	1: "AMP",
	2: "AMP4ADS",
	3: "AMP4EMAIL",
	4: "EXPERIMENTAL",
}

var HtmlFormat_Code_value = map[string]int32{
	"UNKNOWN_CODE": 0,
	"AMP":          1,
	"AMP4ADS":      2,
	"AMP4EMAIL":    3,
	"EXPERIMENTAL": 4,
}

func (x HtmlFormat_Code) Enum() *HtmlFormat_Code {
	p := new(HtmlFormat_Code)
	*p = x
	return p
}

func (x HtmlFormat_Code) String() string {
	return proto.EnumName(HtmlFormat_Code_name, int32(x))
}

func (x *HtmlFormat_Code) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(HtmlFormat_Code_value, data, "HtmlFormat_Code")
	if err != nil {
		return err
	}
	*x = HtmlFormat_Code(value)
	return nil
}

func (HtmlFormat_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{20, 0}
}

// NamedId's are used to uniquely identify specific TagSpecs in the
// validator rules in a stable manner. Most TagSpecs have no set NamedId.
// If a TagSpec has a NamedId it must be unique. In other words, no two
// TagSpec's may have the same NamedId except for the NOT_SET (0) value.
// NEXT AVAILABLE TAG: 3
type TagSpec_NamedId int32

const (
	TagSpec_NOT_SET TagSpec_NamedId = 0
	// By convention, the first "word" in the Id should be the tag_name.
	TagSpec_LINK_FONT_STYLESHEET TagSpec_NamedId = 1
	TagSpec_STYLE_AMP_CUSTOM     TagSpec_NamedId = 2
)

var TagSpec_NamedId_name = map[int32]string{
	0: "NOT_SET",
	1: "LINK_FONT_STYLESHEET",
	2: "STYLE_AMP_CUSTOM",
}

var TagSpec_NamedId_value = map[string]int32{
	"NOT_SET":              0,
	"LINK_FONT_STYLESHEET": 1,
	"STYLE_AMP_CUSTOM":     2,
}

func (x TagSpec_NamedId) Enum() *TagSpec_NamedId {
	p := new(TagSpec_NamedId)
	*p = x
	return p
}

func (x TagSpec_NamedId) String() string {
	return proto.EnumName(TagSpec_NamedId_name, int32(x))
}

func (x *TagSpec_NamedId) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TagSpec_NamedId_value, data, "TagSpec_NamedId")
	if err != nil {
		return err
	}
	*x = TagSpec_NamedId(value)
	return nil
}

func (TagSpec_NamedId) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{21, 0}
}

type ErrorCategory_Code int32

const (
	ErrorCategory_UNKNOWN ErrorCategory_Code = 0
)

var ErrorCategory_Code_name = map[int32]string{
	0: "UNKNOWN",
}

var ErrorCategory_Code_value = map[string]int32{
	"UNKNOWN": 0,
}

func (x ErrorCategory_Code) Enum() *ErrorCategory_Code {
	p := new(ErrorCategory_Code)
	*p = x
	return p
}

func (x ErrorCategory_Code) String() string {
	return proto.EnumName(ErrorCategory_Code_name, int32(x))
}

func (x *ErrorCategory_Code) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ErrorCategory_Code_value, data, "ErrorCategory_Code")
	if err != nil {
		return err
	}
	*x = ErrorCategory_Code(value)
	return nil
}

func (ErrorCategory_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{25, 0}
}

// NEXT AVAILABLE TAG: 5
type ValidationError_Severity int32

const (
	ValidationError_UNKNOWN_SEVERITY ValidationError_Severity = 0
	// A document with at least one error of this severity fails validation.
	ValidationError_ERROR ValidationError_Severity = 1
	// A document may have warnings and still pass validation.
	ValidationError_WARNING ValidationError_Severity = 4
)

var ValidationError_Severity_name = map[int32]string{
	0: "UNKNOWN_SEVERITY",
	1: "ERROR",
	4: "WARNING",
}

var ValidationError_Severity_value = map[string]int32{
	"UNKNOWN_SEVERITY": 0,
	"ERROR":            1,
	"WARNING":          4,
}

func (x ValidationError_Severity) Enum() *ValidationError_Severity {
	p := new(ValidationError_Severity)
	*p = x
	return p
}

func (x ValidationError_Severity) String() string {
	return proto.EnumName(ValidationError_Severity_name, int32(x))
}

func (x *ValidationError_Severity) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ValidationError_Severity_value, data, "ValidationError_Severity")
	if err != nil {
		return err
	}
	*x = ValidationError_Severity(value)
	return nil
}

func (ValidationError_Severity) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{26, 0}
}

// NEXT AVAILABLE TAG: 121
type ValidationError_Code int32

const (
	ValidationError_UNKNOWN_CODE                                        ValidationError_Code = 0
	ValidationError_INVALID_DOCTYPE_HTML                                ValidationError_Code = 111
	ValidationError_MANDATORY_TAG_MISSING                               ValidationError_Code = 1
	ValidationError_TAG_REQUIRED_BY_MISSING                             ValidationError_Code = 24
	ValidationError_WARNING_TAG_REQUIRED_BY_MISSING                     ValidationError_Code = 76
	ValidationError_TAG_EXCLUDED_BY_TAG                                 ValidationError_Code = 101
	ValidationError_WARNING_EXTENSION_UNUSED                            ValidationError_Code = 79
	ValidationError_EXTENSION_UNUSED                                    ValidationError_Code = 84
	ValidationError_WARNING_EXTENSION_DEPRECATED_VERSION                ValidationError_Code = 80
	ValidationError_NON_LTS_SCRIPT_AFTER_LTS                            ValidationError_Code = 112
	ValidationError_LTS_SCRIPT_AFTER_NON_LTS                            ValidationError_Code = 113
	ValidationError_INCORRECT_SCRIPT_RELEASE_VERSION                    ValidationError_Code = 119
	ValidationError_ATTR_REQUIRED_BUT_MISSING                           ValidationError_Code = 61
	ValidationError_DISALLOWED_TAG                                      ValidationError_Code = 2
	ValidationError_GENERAL_DISALLOWED_TAG                              ValidationError_Code = 51
	ValidationError_DISALLOWED_SCRIPT_TAG                               ValidationError_Code = 88
	ValidationError_DISALLOWED_ATTR                                     ValidationError_Code = 3
	ValidationError_DISALLOWED_STYLE_ATTR                               ValidationError_Code = 81
	ValidationError_INVALID_ATTR_VALUE                                  ValidationError_Code = 4
	ValidationError_DUPLICATE_ATTRIBUTE                                 ValidationError_Code = 94
	ValidationError_ATTR_VALUE_REQUIRED_BY_LAYOUT                       ValidationError_Code = 27
	ValidationError_MISSING_LAYOUT_ATTRIBUTES                           ValidationError_Code = 105
	ValidationError_IMPLIED_LAYOUT_INVALID                              ValidationError_Code = 22
	ValidationError_SPECIFIED_LAYOUT_INVALID                            ValidationError_Code = 26
	ValidationError_MANDATORY_ATTR_MISSING                              ValidationError_Code = 5
	ValidationError_MANDATORY_ONEOF_ATTR_MISSING                        ValidationError_Code = 28
	ValidationError_MANDATORY_ANYOF_ATTR_MISSING                        ValidationError_Code = 104
	ValidationError_DUPLICATE_DIMENSION                                 ValidationError_Code = 60
	ValidationError_DUPLICATE_UNIQUE_TAG                                ValidationError_Code = 6
	ValidationError_DUPLICATE_UNIQUE_TAG_WARNING                        ValidationError_Code = 77
	ValidationError_WRONG_PARENT_TAG                                    ValidationError_Code = 7
	ValidationError_STYLESHEET_TOO_LONG                                 ValidationError_Code = 50
	ValidationError_STYLESHEET_AND_INLINE_STYLE_TOO_LONG                ValidationError_Code = 102
	ValidationError_INLINE_STYLE_TOO_LONG                               ValidationError_Code = 103
	ValidationError_INLINE_SCRIPT_TOO_LONG                              ValidationError_Code = 118
	ValidationError_MANDATORY_CDATA_MISSING_OR_INCORRECT                ValidationError_Code = 9
	ValidationError_CDATA_VIOLATES_DENYLIST                             ValidationError_Code = 30
	ValidationError_NON_WHITESPACE_CDATA_ENCOUNTERED                    ValidationError_Code = 82
	ValidationError_INVALID_JSON_CDATA                                  ValidationError_Code = 106
	ValidationError_DEPRECATED_ATTR                                     ValidationError_Code = 11
	ValidationError_DEPRECATED_TAG                                      ValidationError_Code = 12
	ValidationError_MANDATORY_PROPERTY_MISSING_FROM_ATTR_VALUE          ValidationError_Code = 14
	ValidationError_INVALID_PROPERTY_VALUE_IN_ATTR_VALUE                ValidationError_Code = 15
	ValidationError_MISSING_URL                                         ValidationError_Code = 35
	ValidationError_INVALID_URL                                         ValidationError_Code = 36
	ValidationError_INVALID_URL_PROTOCOL                                ValidationError_Code = 37
	ValidationError_DISALLOWED_DOMAIN                                   ValidationError_Code = 62
	ValidationError_DISALLOWED_RELATIVE_URL                             ValidationError_Code = 49
	ValidationError_DISALLOWED_PROPERTY_IN_ATTR_VALUE                   ValidationError_Code = 16
	ValidationError_MUTUALLY_EXCLUSIVE_ATTRS                            ValidationError_Code = 17
	ValidationError_UNESCAPED_TEMPLATE_IN_ATTR_VALUE                    ValidationError_Code = 18
	ValidationError_TEMPLATE_PARTIAL_IN_ATTR_VALUE                      ValidationError_Code = 19
	ValidationError_TEMPLATE_IN_ATTR_NAME                               ValidationError_Code = 20
	ValidationError_INCONSISTENT_UNITS_FOR_WIDTH_AND_HEIGHT             ValidationError_Code = 21
	ValidationError_DISALLOWED_TAG_ANCESTOR                             ValidationError_Code = 23
	ValidationError_MANDATORY_LAST_CHILD_TAG                            ValidationError_Code = 89
	ValidationError_MANDATORY_TAG_ANCESTOR                              ValidationError_Code = 31
	ValidationError_MANDATORY_TAG_ANCESTOR_WITH_HINT                    ValidationError_Code = 32
	ValidationError_ATTR_DISALLOWED_BY_IMPLIED_LAYOUT                   ValidationError_Code = 33
	ValidationError_ATTR_DISALLOWED_BY_SPECIFIED_LAYOUT                 ValidationError_Code = 34
	ValidationError_INCORRECT_NUM_CHILD_TAGS                            ValidationError_Code = 56
	ValidationError_INCORRECT_MIN_NUM_CHILD_TAGS                        ValidationError_Code = 85
	ValidationError_DISALLOWED_CHILD_TAG_NAME                           ValidationError_Code = 57
	ValidationError_DISALLOWED_FIRST_CHILD_TAG_NAME                     ValidationError_Code = 58
	ValidationError_DISALLOWED_MANUFACTURED_BODY                        ValidationError_Code = 64
	ValidationError_CHILD_TAG_DOES_NOT_SATISFY_REFERENCE_POINT          ValidationError_Code = 66
	ValidationError_MANDATORY_REFERENCE_POINT_MISSING                   ValidationError_Code = 67
	ValidationError_DUPLICATE_REFERENCE_POINT                           ValidationError_Code = 68
	ValidationError_TAG_NOT_ALLOWED_TO_HAVE_SIBLINGS                    ValidationError_Code = 87
	ValidationError_TAG_REFERENCE_POINT_CONFLICT                        ValidationError_Code = 69
	ValidationError_CHILD_TAG_DOES_NOT_SATISFY_REFERENCE_POINT_SINGULAR ValidationError_Code = 70
	// TODO(gregable): Fix this spelling error: 'precede'
	ValidationError_BASE_TAG_MUST_PRECEED_ALL_URLS                               ValidationError_Code = 78
	ValidationError_MISSING_REQUIRED_EXTENSION                                   ValidationError_Code = 83
	ValidationError_ATTR_MISSING_REQUIRED_EXTENSION                              ValidationError_Code = 97
	ValidationError_DOCUMENT_TOO_COMPLEX                                         ValidationError_Code = 86
	ValidationError_INVALID_UTF8                                                 ValidationError_Code = 96
	ValidationError_DOCUMENT_SIZE_LIMIT_EXCEEDED                                 ValidationError_Code = 108
	ValidationError_DEV_MODE_ONLY                                                ValidationError_Code = 109
	ValidationError_AMP_EMAIL_MISSING_STRICT_CSS_ATTR                            ValidationError_Code = 120
	ValidationError_VALUE_SET_MISMATCH                                           ValidationError_Code = 110
	ValidationError_CSS_SYNTAX_INVALID_AT_RULE                                   ValidationError_Code = 29
	ValidationError_CSS_SYNTAX_STRAY_TRAILING_BACKSLASH                          ValidationError_Code = 38
	ValidationError_CSS_SYNTAX_UNTERMINATED_COMMENT                              ValidationError_Code = 39
	ValidationError_CSS_SYNTAX_UNTERMINATED_STRING                               ValidationError_Code = 40
	ValidationError_CSS_SYNTAX_BAD_URL                                           ValidationError_Code = 41
	ValidationError_CSS_SYNTAX_EOF_IN_PRELUDE_OF_QUALIFIED_RULE                  ValidationError_Code = 42
	ValidationError_CSS_SYNTAX_INVALID_DECLARATION                               ValidationError_Code = 43
	ValidationError_CSS_SYNTAX_INCOMPLETE_DECLARATION                            ValidationError_Code = 44
	ValidationError_CSS_SYNTAX_ERROR_IN_PSEUDO_SELECTOR                          ValidationError_Code = 45
	ValidationError_CSS_SYNTAX_MISSING_SELECTOR                                  ValidationError_Code = 46
	ValidationError_CSS_SYNTAX_NOT_A_SELECTOR_START                              ValidationError_Code = 47
	ValidationError_CSS_SYNTAX_UNPARSED_INPUT_REMAINS_IN_SELECTOR                ValidationError_Code = 48
	ValidationError_CSS_SYNTAX_MISSING_URL                                       ValidationError_Code = 52
	ValidationError_CSS_SYNTAX_INVALID_URL                                       ValidationError_Code = 53
	ValidationError_CSS_SYNTAX_INVALID_URL_PROTOCOL                              ValidationError_Code = 54
	ValidationError_CSS_SYNTAX_DISALLOWED_DOMAIN                                 ValidationError_Code = 63
	ValidationError_CSS_SYNTAX_DISALLOWED_RELATIVE_URL                           ValidationError_Code = 55
	ValidationError_CSS_SYNTAX_INVALID_ATTR_SELECTOR                             ValidationError_Code = 59
	ValidationError_CSS_SYNTAX_INVALID_PROPERTY                                  ValidationError_Code = 90
	ValidationError_CSS_SYNTAX_INVALID_PROPERTY_NOLIST                           ValidationError_Code = 95
	ValidationError_CSS_SYNTAX_QUALIFIED_RULE_HAS_NO_DECLARATIONS                ValidationError_Code = 91
	ValidationError_CSS_SYNTAX_DISALLOWED_QUALIFIED_RULE_MUST_BE_INSIDE_KEYFRAME ValidationError_Code = 92
	ValidationError_CSS_SYNTAX_DISALLOWED_KEYFRAME_INSIDE_KEYFRAME               ValidationError_Code = 93
	ValidationError_CSS_SYNTAX_MALFORMED_MEDIA_QUERY                             ValidationError_Code = 98
	ValidationError_CSS_SYNTAX_DISALLOWED_MEDIA_TYPE                             ValidationError_Code = 99
	ValidationError_CSS_SYNTAX_DISALLOWED_MEDIA_FEATURE                          ValidationError_Code = 100
	ValidationError_CSS_SYNTAX_DISALLOWED_ATTR_SELECTOR                          ValidationError_Code = 114
	ValidationError_CSS_SYNTAX_DISALLOWED_PSEUDO_CLASS                           ValidationError_Code = 115
	ValidationError_CSS_SYNTAX_DISALLOWED_PSEUDO_ELEMENT                         ValidationError_Code = 116
	ValidationError_CSS_SYNTAX_DISALLOWED_PROPERTY_VALUE                         ValidationError_Code = 71
	ValidationError_CSS_SYNTAX_DISALLOWED_IMPORTANT                              ValidationError_Code = 117
	ValidationError_CSS_EXCESSIVELY_NESTED                                       ValidationError_Code = 107
	// The following codes are currently used only by A4A CSS validation.
	ValidationError_CSS_SYNTAX_DISALLOWED_PROPERTY_VALUE_WITH_HINT ValidationError_Code = 72
	ValidationError_CSS_SYNTAX_PROPERTY_DISALLOWED_WITHIN_AT_RULE  ValidationError_Code = 73
	ValidationError_CSS_SYNTAX_PROPERTY_DISALLOWED_TOGETHER_WITH   ValidationError_Code = 74
	ValidationError_CSS_SYNTAX_PROPERTY_REQUIRES_QUALIFICATION     ValidationError_Code = 75
)

var ValidationError_Code_name = map[int32]string{
	0:   "UNKNOWN_CODE",
	111: "INVALID_DOCTYPE_HTML",
	1:   "MANDATORY_TAG_MISSING",
	24:  "TAG_REQUIRED_BY_MISSING",
	76:  "WARNING_TAG_REQUIRED_BY_MISSING",
	101: "TAG_EXCLUDED_BY_TAG",
	79:  "WARNING_EXTENSION_UNUSED",
	84:  "EXTENSION_UNUSED",
	80:  "WARNING_EXTENSION_DEPRECATED_VERSION",
	112: "NON_LTS_SCRIPT_AFTER_LTS",
	113: "LTS_SCRIPT_AFTER_NON_LTS",
	119: "INCORRECT_SCRIPT_RELEASE_VERSION",
	61:  "ATTR_REQUIRED_BUT_MISSING",
	2:   "DISALLOWED_TAG",
	51:  "GENERAL_DISALLOWED_TAG",
	88:  "DISALLOWED_SCRIPT_TAG",
	3:   "DISALLOWED_ATTR",
	81:  "DISALLOWED_STYLE_ATTR",
	4:   "INVALID_ATTR_VALUE",
	94:  "DUPLICATE_ATTRIBUTE",
	27:  "ATTR_VALUE_REQUIRED_BY_LAYOUT",
	105: "MISSING_LAYOUT_ATTRIBUTES",
	22:  "IMPLIED_LAYOUT_INVALID",
	26:  "SPECIFIED_LAYOUT_INVALID",
	5:   "MANDATORY_ATTR_MISSING",
	28:  "MANDATORY_ONEOF_ATTR_MISSING",
	104: "MANDATORY_ANYOF_ATTR_MISSING",
	60:  "DUPLICATE_DIMENSION",
	6:   "DUPLICATE_UNIQUE_TAG",
	77:  "DUPLICATE_UNIQUE_TAG_WARNING",
	7:   "WRONG_PARENT_TAG",
	50:  "STYLESHEET_TOO_LONG",
	102: "STYLESHEET_AND_INLINE_STYLE_TOO_LONG",
	103: "INLINE_STYLE_TOO_LONG",
	118: "INLINE_SCRIPT_TOO_LONG",
	9:   "MANDATORY_CDATA_MISSING_OR_INCORRECT",
	30:  "CDATA_VIOLATES_DENYLIST",
	82:  "NON_WHITESPACE_CDATA_ENCOUNTERED",
	106: "INVALID_JSON_CDATA",
	11:  "DEPRECATED_ATTR",
	12:  "DEPRECATED_TAG",
	14:  "MANDATORY_PROPERTY_MISSING_FROM_ATTR_VALUE",
	15:  "INVALID_PROPERTY_VALUE_IN_ATTR_VALUE",
	35:  "MISSING_URL",
	36:  "INVALID_URL",
	37:  "INVALID_URL_PROTOCOL",
	62:  "DISALLOWED_DOMAIN",
	49:  "DISALLOWED_RELATIVE_URL",
	16:  "DISALLOWED_PROPERTY_IN_ATTR_VALUE",
	17:  "MUTUALLY_EXCLUSIVE_ATTRS",
	18:  "UNESCAPED_TEMPLATE_IN_ATTR_VALUE",
	19:  "TEMPLATE_PARTIAL_IN_ATTR_VALUE",
	20:  "TEMPLATE_IN_ATTR_NAME",
	21:  "INCONSISTENT_UNITS_FOR_WIDTH_AND_HEIGHT",
	23:  "DISALLOWED_TAG_ANCESTOR",
	89:  "MANDATORY_LAST_CHILD_TAG",
	31:  "MANDATORY_TAG_ANCESTOR",
	32:  "MANDATORY_TAG_ANCESTOR_WITH_HINT",
	33:  "ATTR_DISALLOWED_BY_IMPLIED_LAYOUT",
	34:  "ATTR_DISALLOWED_BY_SPECIFIED_LAYOUT",
	56:  "INCORRECT_NUM_CHILD_TAGS",
	85:  "INCORRECT_MIN_NUM_CHILD_TAGS",
	57:  "DISALLOWED_CHILD_TAG_NAME",
	58:  "DISALLOWED_FIRST_CHILD_TAG_NAME",
	64:  "DISALLOWED_MANUFACTURED_BODY",
	66:  "CHILD_TAG_DOES_NOT_SATISFY_REFERENCE_POINT",
	67:  "MANDATORY_REFERENCE_POINT_MISSING",
	68:  "DUPLICATE_REFERENCE_POINT",
	87:  "TAG_NOT_ALLOWED_TO_HAVE_SIBLINGS",
	69:  "TAG_REFERENCE_POINT_CONFLICT",
	70:  "CHILD_TAG_DOES_NOT_SATISFY_REFERENCE_POINT_SINGULAR",
	78:  "BASE_TAG_MUST_PRECEED_ALL_URLS",
	83:  "MISSING_REQUIRED_EXTENSION",
	97:  "ATTR_MISSING_REQUIRED_EXTENSION",
	86:  "DOCUMENT_TOO_COMPLEX",
	96:  "INVALID_UTF8",
	108: "DOCUMENT_SIZE_LIMIT_EXCEEDED",
	109: "DEV_MODE_ONLY",
	120: "AMP_EMAIL_MISSING_STRICT_CSS_ATTR",
	110: "VALUE_SET_MISMATCH",
	29:  "CSS_SYNTAX_INVALID_AT_RULE",
	38:  "CSS_SYNTAX_STRAY_TRAILING_BACKSLASH",
	39:  "CSS_SYNTAX_UNTERMINATED_COMMENT",
	40:  "CSS_SYNTAX_UNTERMINATED_STRING",
	41:  "CSS_SYNTAX_BAD_URL",
	42:  "CSS_SYNTAX_EOF_IN_PRELUDE_OF_QUALIFIED_RULE",
	43:  "CSS_SYNTAX_INVALID_DECLARATION",
	44:  "CSS_SYNTAX_INCOMPLETE_DECLARATION",
	45:  "CSS_SYNTAX_ERROR_IN_PSEUDO_SELECTOR",
	46:  "CSS_SYNTAX_MISSING_SELECTOR",
	47:  "CSS_SYNTAX_NOT_A_SELECTOR_START",
	48:  "CSS_SYNTAX_UNPARSED_INPUT_REMAINS_IN_SELECTOR",
	52:  "CSS_SYNTAX_MISSING_URL",
	53:  "CSS_SYNTAX_INVALID_URL",
	54:  "CSS_SYNTAX_INVALID_URL_PROTOCOL",
	63:  "CSS_SYNTAX_DISALLOWED_DOMAIN",
	55:  "CSS_SYNTAX_DISALLOWED_RELATIVE_URL",
	59:  "CSS_SYNTAX_INVALID_ATTR_SELECTOR",
	90:  "CSS_SYNTAX_INVALID_PROPERTY",
	95:  "CSS_SYNTAX_INVALID_PROPERTY_NOLIST",
	91:  "CSS_SYNTAX_QUALIFIED_RULE_HAS_NO_DECLARATIONS",
	92:  "CSS_SYNTAX_DISALLOWED_QUALIFIED_RULE_MUST_BE_INSIDE_KEYFRAME",
	93:  "CSS_SYNTAX_DISALLOWED_KEYFRAME_INSIDE_KEYFRAME",
	98:  "CSS_SYNTAX_MALFORMED_MEDIA_QUERY",
	99:  "CSS_SYNTAX_DISALLOWED_MEDIA_TYPE",
	100: "CSS_SYNTAX_DISALLOWED_MEDIA_FEATURE",
	114: "CSS_SYNTAX_DISALLOWED_ATTR_SELECTOR",
	115: "CSS_SYNTAX_DISALLOWED_PSEUDO_CLASS",
	116: "CSS_SYNTAX_DISALLOWED_PSEUDO_ELEMENT",
	71:  "CSS_SYNTAX_DISALLOWED_PROPERTY_VALUE",
	117: "CSS_SYNTAX_DISALLOWED_IMPORTANT",
	107: "CSS_EXCESSIVELY_NESTED",
	72:  "CSS_SYNTAX_DISALLOWED_PROPERTY_VALUE_WITH_HINT",
	73:  "CSS_SYNTAX_PROPERTY_DISALLOWED_WITHIN_AT_RULE",
	74:  "CSS_SYNTAX_PROPERTY_DISALLOWED_TOGETHER_WITH",
	75:  "CSS_SYNTAX_PROPERTY_REQUIRES_QUALIFICATION",
}

var ValidationError_Code_value = map[string]int32{
	"UNKNOWN_CODE":                                                 0,
	"INVALID_DOCTYPE_HTML":                                         111,
	"MANDATORY_TAG_MISSING":                                        1,
	"TAG_REQUIRED_BY_MISSING":                                      24,
	"WARNING_TAG_REQUIRED_BY_MISSING":                              76,
	"TAG_EXCLUDED_BY_TAG":                                          101,
	"WARNING_EXTENSION_UNUSED":                                     79,
	"EXTENSION_UNUSED":                                             84,
	"WARNING_EXTENSION_DEPRECATED_VERSION":                         80,
	"NON_LTS_SCRIPT_AFTER_LTS":                                     112,
	"LTS_SCRIPT_AFTER_NON_LTS":                                     113,
	"INCORRECT_SCRIPT_RELEASE_VERSION":                             119,
	"ATTR_REQUIRED_BUT_MISSING":                                    61,
	"DISALLOWED_TAG":                                               2,
	"GENERAL_DISALLOWED_TAG":                                       51,
	"DISALLOWED_SCRIPT_TAG":                                        88,
	"DISALLOWED_ATTR":                                              3,
	"DISALLOWED_STYLE_ATTR":                                        81,
	"INVALID_ATTR_VALUE":                                           4,
	"DUPLICATE_ATTRIBUTE":                                          94,
	"ATTR_VALUE_REQUIRED_BY_LAYOUT":                                27,
	"MISSING_LAYOUT_ATTRIBUTES":                                    105,
	"IMPLIED_LAYOUT_INVALID":                                       22,
	"SPECIFIED_LAYOUT_INVALID":                                     26,
	"MANDATORY_ATTR_MISSING":                                       5,
	"MANDATORY_ONEOF_ATTR_MISSING":                                 28,
	"MANDATORY_ANYOF_ATTR_MISSING":                                 104,
	"DUPLICATE_DIMENSION":                                          60,
	"DUPLICATE_UNIQUE_TAG":                                         6,
	"DUPLICATE_UNIQUE_TAG_WARNING":                                 77,
	"WRONG_PARENT_TAG":                                             7,
	"STYLESHEET_TOO_LONG":                                          50,
	"STYLESHEET_AND_INLINE_STYLE_TOO_LONG":                         102,
	"INLINE_STYLE_TOO_LONG":                                        103,
	"INLINE_SCRIPT_TOO_LONG":                                       118,
	"MANDATORY_CDATA_MISSING_OR_INCORRECT":                         9,
	"CDATA_VIOLATES_DENYLIST":                                      30,
	"NON_WHITESPACE_CDATA_ENCOUNTERED":                             82,
	"INVALID_JSON_CDATA":                                           106,
	"DEPRECATED_ATTR":                                              11,
	"DEPRECATED_TAG":                                               12,
	"MANDATORY_PROPERTY_MISSING_FROM_ATTR_VALUE":                   14,
	"INVALID_PROPERTY_VALUE_IN_ATTR_VALUE":                         15,
	"MISSING_URL":                                                  35,
	"INVALID_URL":                                                  36,
	"INVALID_URL_PROTOCOL":                                         37,
	"DISALLOWED_DOMAIN":                                            62,
	"DISALLOWED_RELATIVE_URL":                                      49,
	"DISALLOWED_PROPERTY_IN_ATTR_VALUE":                            16,
	"MUTUALLY_EXCLUSIVE_ATTRS":                                     17,
	"UNESCAPED_TEMPLATE_IN_ATTR_VALUE":                             18,
	"TEMPLATE_PARTIAL_IN_ATTR_VALUE":                               19,
	"TEMPLATE_IN_ATTR_NAME":                                        20,
	"INCONSISTENT_UNITS_FOR_WIDTH_AND_HEIGHT":                      21,
	"DISALLOWED_TAG_ANCESTOR":                                      23,
	"MANDATORY_LAST_CHILD_TAG":                                     89,
	"MANDATORY_TAG_ANCESTOR":                                       31,
	"MANDATORY_TAG_ANCESTOR_WITH_HINT":                             32,
	"ATTR_DISALLOWED_BY_IMPLIED_LAYOUT":                            33,
	"ATTR_DISALLOWED_BY_SPECIFIED_LAYOUT":                          34,
	"INCORRECT_NUM_CHILD_TAGS":                                     56,
	"INCORRECT_MIN_NUM_CHILD_TAGS":                                 85,
	"DISALLOWED_CHILD_TAG_NAME":                                    57,
	"DISALLOWED_FIRST_CHILD_TAG_NAME":                              58,
	"DISALLOWED_MANUFACTURED_BODY":                                 64,
	"CHILD_TAG_DOES_NOT_SATISFY_REFERENCE_POINT":                   66,
	"MANDATORY_REFERENCE_POINT_MISSING":                            67,
	"DUPLICATE_REFERENCE_POINT":                                    68,
	"TAG_NOT_ALLOWED_TO_HAVE_SIBLINGS":                             87,
	"TAG_REFERENCE_POINT_CONFLICT":                                 69,
	"CHILD_TAG_DOES_NOT_SATISFY_REFERENCE_POINT_SINGULAR":          70,
	"BASE_TAG_MUST_PRECEED_ALL_URLS":                               78,
	"MISSING_REQUIRED_EXTENSION":                                   83,
	"ATTR_MISSING_REQUIRED_EXTENSION":                              97,
	"DOCUMENT_TOO_COMPLEX":                                         86,
	"INVALID_UTF8":                                                 96,
	"DOCUMENT_SIZE_LIMIT_EXCEEDED":                                 108,
	"DEV_MODE_ONLY":                                                109,
	"AMP_EMAIL_MISSING_STRICT_CSS_ATTR":                            120,
	"VALUE_SET_MISMATCH":                                           110,
	"CSS_SYNTAX_INVALID_AT_RULE":                                   29,
	"CSS_SYNTAX_STRAY_TRAILING_BACKSLASH":                          38,
	"CSS_SYNTAX_UNTERMINATED_COMMENT":                              39,
	"CSS_SYNTAX_UNTERMINATED_STRING":                               40,
	"CSS_SYNTAX_BAD_URL":                                           41,
	"CSS_SYNTAX_EOF_IN_PRELUDE_OF_QUALIFIED_RULE":                  42,
	"CSS_SYNTAX_INVALID_DECLARATION":                               43,
	"CSS_SYNTAX_INCOMPLETE_DECLARATION":                            44,
	"CSS_SYNTAX_ERROR_IN_PSEUDO_SELECTOR":                          45,
	"CSS_SYNTAX_MISSING_SELECTOR":                                  46,
	"CSS_SYNTAX_NOT_A_SELECTOR_START":                              47,
	"CSS_SYNTAX_UNPARSED_INPUT_REMAINS_IN_SELECTOR":                48,
	"CSS_SYNTAX_MISSING_URL":                                       52,
	"CSS_SYNTAX_INVALID_URL":                                       53,
	"CSS_SYNTAX_INVALID_URL_PROTOCOL":                              54,
	"CSS_SYNTAX_DISALLOWED_DOMAIN":                                 63,
	"CSS_SYNTAX_DISALLOWED_RELATIVE_URL":                           55,
	"CSS_SYNTAX_INVALID_ATTR_SELECTOR":                             59,
	"CSS_SYNTAX_INVALID_PROPERTY":                                  90,
	"CSS_SYNTAX_INVALID_PROPERTY_NOLIST":                           95,
	"CSS_SYNTAX_QUALIFIED_RULE_HAS_NO_DECLARATIONS":                91,
	"CSS_SYNTAX_DISALLOWED_QUALIFIED_RULE_MUST_BE_INSIDE_KEYFRAME": 92,
	"CSS_SYNTAX_DISALLOWED_KEYFRAME_INSIDE_KEYFRAME":               93,
	"CSS_SYNTAX_MALFORMED_MEDIA_QUERY":                             98,
	"CSS_SYNTAX_DISALLOWED_MEDIA_TYPE":                             99,
	"CSS_SYNTAX_DISALLOWED_MEDIA_FEATURE":                          100,
	"CSS_SYNTAX_DISALLOWED_ATTR_SELECTOR":                          114,
	"CSS_SYNTAX_DISALLOWED_PSEUDO_CLASS":                           115,
	"CSS_SYNTAX_DISALLOWED_PSEUDO_ELEMENT":                         116,
	"CSS_SYNTAX_DISALLOWED_PROPERTY_VALUE":                         71,
	"CSS_SYNTAX_DISALLOWED_IMPORTANT":                              117,
	"CSS_EXCESSIVELY_NESTED":                                       107,
	"CSS_SYNTAX_DISALLOWED_PROPERTY_VALUE_WITH_HINT":               72,
	"CSS_SYNTAX_PROPERTY_DISALLOWED_WITHIN_AT_RULE":                73,
	"CSS_SYNTAX_PROPERTY_DISALLOWED_TOGETHER_WITH":                 74,
	"CSS_SYNTAX_PROPERTY_REQUIRES_QUALIFICATION":                   75,
}

func (x ValidationError_Code) Enum() *ValidationError_Code {
	p := new(ValidationError_Code)
	*p = x
	return p
}

func (x ValidationError_Code) String() string {
	return proto.EnumName(ValidationError_Code_name, int32(x))
}

func (x *ValidationError_Code) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ValidationError_Code_value, data, "ValidationError_Code")
	if err != nil {
		return err
	}
	*x = ValidationError_Code(value)
	return nil
}

func (ValidationError_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{26, 1}
}

// NEXT AVAILABLE TAG: 3
type ValidationResult_Status int32

const (
	ValidationResult_UNKNOWN ValidationResult_Status = 0
	ValidationResult_PASS    ValidationResult_Status = 1
	ValidationResult_FAIL    ValidationResult_Status = 2
)

var ValidationResult_Status_name = map[int32]string{
	0: "UNKNOWN",
	1: "PASS",
	2: "FAIL",
}

var ValidationResult_Status_value = map[string]int32{
	"UNKNOWN": 0,
	"PASS":    1,
	"FAIL":    2,
}

func (x ValidationResult_Status) Enum() *ValidationResult_Status {
	p := new(ValidationResult_Status)
	*p = x
	return p
}

func (x ValidationResult_Status) String() string {
	return proto.EnumName(ValidationResult_Status_name, int32(x))
}

func (x *ValidationResult_Status) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ValidationResult_Status_value, data, "ValidationResult_Status")
	if err != nil {
		return err
	}
	*x = ValidationResult_Status(value)
	return nil
}

func (ValidationResult_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{31, 0}
}

// Used for validating attributes that require another attribute for some
// given set of conditions.
// E.g. attr name: "on" if_value_regex: "tap:.*" also_require_attr: "role"
// NEXT AVAILABLE TAG: 3
type AttrTriggerSpec struct {
	// If set, attribute's value must match to also require attribute(s).
	// If not set, attribute automatically also require attribute(s).
	IfValueRegex *string `protobuf:"bytes,1,opt,name=if_value_regex,json=ifValueRegex" json:"if_value_regex,omitempty"`
	// If set, other attributes - identified by their name string - must
	// be present as well.
	AlsoRequiresAttr     []string `protobuf:"bytes,2,rep,name=also_requires_attr,json=alsoRequiresAttr" json:"also_requires_attr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AttrTriggerSpec) Reset()         { *m = AttrTriggerSpec{} }
func (m *AttrTriggerSpec) String() string { return proto.CompactTextString(m) }
func (*AttrTriggerSpec) ProtoMessage()    {}
func (*AttrTriggerSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{0}
}

func (m *AttrTriggerSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AttrTriggerSpec.Unmarshal(m, b)
}
func (m *AttrTriggerSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AttrTriggerSpec.Marshal(b, m, deterministic)
}
func (m *AttrTriggerSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttrTriggerSpec.Merge(m, src)
}
func (m *AttrTriggerSpec) XXX_Size() int {
	return xxx_messageInfo_AttrTriggerSpec.Size(m)
}
func (m *AttrTriggerSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AttrTriggerSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AttrTriggerSpec proto.InternalMessageInfo

func (m *AttrTriggerSpec) GetIfValueRegex() string {
	if m != nil && m.IfValueRegex != nil {
		return *m.IfValueRegex
	}
	return ""
}

func (m *AttrTriggerSpec) GetAlsoRequiresAttr() []string {
	if m != nil {
		return m.AlsoRequiresAttr
	}
	return nil
}

// Used for validating properties in attribute values. Our validator
// (via parse-viewport.h) implements the parsing algorithm as described here:
// https://drafts.csswg.org/css-device-adapt/#parsing-algorithm
// NEXT AVAILABLE TAG: 5
type PropertySpec struct {
	// Must be lowercase, and will be matched case-insensitively.
	Name      *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Mandatory *bool   `protobuf:"varint,2,opt,name=mandatory" json:"mandatory,omitempty"`
	// Must be lowercase, and will be matched case-insensitively.
	Value                *string  `protobuf:"bytes,3,opt,name=value" json:"value,omitempty"`
	ValueDouble          *float64 `protobuf:"fixed64,4,opt,name=value_double,json=valueDouble" json:"value_double,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PropertySpec) Reset()         { *m = PropertySpec{} }
func (m *PropertySpec) String() string { return proto.CompactTextString(m) }
func (*PropertySpec) ProtoMessage()    {}
func (*PropertySpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{1}
}

func (m *PropertySpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PropertySpec.Unmarshal(m, b)
}
func (m *PropertySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PropertySpec.Marshal(b, m, deterministic)
}
func (m *PropertySpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PropertySpec.Merge(m, src)
}
func (m *PropertySpec) XXX_Size() int {
	return xxx_messageInfo_PropertySpec.Size(m)
}
func (m *PropertySpec) XXX_DiscardUnknown() {
	xxx_messageInfo_PropertySpec.DiscardUnknown(m)
}

var xxx_messageInfo_PropertySpec proto.InternalMessageInfo

func (m *PropertySpec) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *PropertySpec) GetMandatory() bool {
	if m != nil && m.Mandatory != nil {
		return *m.Mandatory
	}
	return false
}

func (m *PropertySpec) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

func (m *PropertySpec) GetValueDouble() float64 {
	if m != nil && m.ValueDouble != nil {
		return *m.ValueDouble
	}
	return 0
}

// NEXT AVAILABLE TAG: 2
type PropertySpecList struct {
	Properties           []*PropertySpec `protobuf:"bytes,1,rep,name=properties" json:"properties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *PropertySpecList) Reset()         { *m = PropertySpecList{} }
func (m *PropertySpecList) String() string { return proto.CompactTextString(m) }
func (*PropertySpecList) ProtoMessage()    {}
func (*PropertySpecList) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{2}
}

func (m *PropertySpecList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PropertySpecList.Unmarshal(m, b)
}
func (m *PropertySpecList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PropertySpecList.Marshal(b, m, deterministic)
}
func (m *PropertySpecList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PropertySpecList.Merge(m, src)
}
func (m *PropertySpecList) XXX_Size() int {
	return xxx_messageInfo_PropertySpecList.Size(m)
}
func (m *PropertySpecList) XXX_DiscardUnknown() {
	xxx_messageInfo_PropertySpecList.DiscardUnknown(m)
}

var xxx_messageInfo_PropertySpecList proto.InternalMessageInfo

func (m *PropertySpecList) GetProperties() []*PropertySpec {
	if m != nil {
		return m.Properties
	}
	return nil
}

// Used for validating urls in attribute values (such as href/src/srcset).
// NEXT AVAILABLE TAG: 5
type UrlSpec struct {
	// protocol must be in lowercase (e.g. "javascript" not "JavaScript").
	Protocol      []string `protobuf:"bytes,1,rep,name=protocol" json:"protocol,omitempty"`
	AllowRelative *bool    `protobuf:"varint,2,opt,name=allow_relative,json=allowRelative,def=1" json:"allow_relative,omitempty"`
	// Whether the empty string '' is allowed for this URL value.
	AllowEmpty           *bool    `protobuf:"varint,3,opt,name=allow_empty,json=allowEmpty,def=0" json:"allow_empty,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UrlSpec) Reset()         { *m = UrlSpec{} }
func (m *UrlSpec) String() string { return proto.CompactTextString(m) }
func (*UrlSpec) ProtoMessage()    {}
func (*UrlSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{3}
}

func (m *UrlSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UrlSpec.Unmarshal(m, b)
}
func (m *UrlSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UrlSpec.Marshal(b, m, deterministic)
}
func (m *UrlSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UrlSpec.Merge(m, src)
}
func (m *UrlSpec) XXX_Size() int {
	return xxx_messageInfo_UrlSpec.Size(m)
}
func (m *UrlSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_UrlSpec.DiscardUnknown(m)
}

var xxx_messageInfo_UrlSpec proto.InternalMessageInfo

const Default_UrlSpec_AllowRelative bool = true
const Default_UrlSpec_AllowEmpty bool = false

func (m *UrlSpec) GetProtocol() []string {
	if m != nil {
		return m.Protocol
	}
	return nil
}

func (m *UrlSpec) GetAllowRelative() bool {
	if m != nil && m.AllowRelative != nil {
		return *m.AllowRelative
	}
	return Default_UrlSpec_AllowRelative
}

func (m *UrlSpec) GetAllowEmpty() bool {
	if m != nil && m.AllowEmpty != nil {
		return *m.AllowEmpty
	}
	return Default_UrlSpec_AllowEmpty
}

// NEXT AVAILABLE TAG: 4
type CssDeclaration struct {
	// The name of the declaration (e.g. display). Use lower-case attribute names
	// only.
	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// This would be a oneof, but this file only uses features in protobuf 2.5.0.
	// begin oneof {
	// The valid values of the declaration (e.g. block).
	ValueCasei           []string `protobuf:"bytes,2,rep,name=value_casei,json=valueCasei" json:"value_casei,omitempty"`
	ValueRegexCasei      *string  `protobuf:"bytes,3,opt,name=value_regex_casei,json=valueRegexCasei" json:"value_regex_casei,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CssDeclaration) Reset()         { *m = CssDeclaration{} }
func (m *CssDeclaration) String() string { return proto.CompactTextString(m) }
func (*CssDeclaration) ProtoMessage()    {}
func (*CssDeclaration) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{4}
}

func (m *CssDeclaration) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CssDeclaration.Unmarshal(m, b)
}
func (m *CssDeclaration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CssDeclaration.Marshal(b, m, deterministic)
}
func (m *CssDeclaration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CssDeclaration.Merge(m, src)
}
func (m *CssDeclaration) XXX_Size() int {
	return xxx_messageInfo_CssDeclaration.Size(m)
}
func (m *CssDeclaration) XXX_DiscardUnknown() {
	xxx_messageInfo_CssDeclaration.DiscardUnknown(m)
}

var xxx_messageInfo_CssDeclaration proto.InternalMessageInfo

func (m *CssDeclaration) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *CssDeclaration) GetValueCasei() []string {
	if m != nil {
		return m.ValueCasei
	}
	return nil
}

func (m *CssDeclaration) GetValueRegexCasei() string {
	if m != nil && m.ValueRegexCasei != nil {
		return *m.ValueRegexCasei
	}
	return ""
}

// Attributes that are not covered by at least one of these specs are
// disallowed. Within a given context (e.g., for a given TagSpec),
// names are unique.
// NEXT AVAILABLE TAG: 29
type AttrSpec struct {
	// If provided, the Type Identifier(s) that either enable or disable
	// this AttrSpec. If a Type Identifier is in enabled_by then this
	// AttrSpec will be used in validating parsed documents with that Type
	// Identifier. If a Type Identifier is in disabled_by then this
	// AttrSpec will not be used in validating parsed documents with that
	// Type Identifier. An AttrSpec can not have both enabled_by and disabled_by
	// set.
	EnabledBy  []string `protobuf:"bytes,23,rep,name=enabled_by,json=enabledBy" json:"enabled_by,omitempty"`
	DisabledBy []string `protobuf:"bytes,24,rep,name=disabled_by,json=disabledBy" json:"disabled_by,omitempty"`
	// Use lower-case attribute names only.
	Name             *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	AlternativeNames []string `protobuf:"bytes,2,rep,name=alternative_names,json=alternativeNames" json:"alternative_names,omitempty"`
	Mandatory        *bool    `protobuf:"varint,3,opt,name=mandatory" json:"mandatory,omitempty"`
	// Within the context of the tag, *exactly one* of the attributes tagged
	// with this identifier must be present. Per convention, this identifier
	// should list the tags participating in the mandatory oneof:
	// e.g. mandatory_oneof: "['foo', 'bar']"
	MandatoryOneof *string `protobuf:"bytes,12,opt,name=mandatory_oneof,json=mandatoryOneof" json:"mandatory_oneof,omitempty"`
	// Within the context of the tag, *at least one* of the attributes tagged
	// with this identifier must be present. Per convention, this identifier
	// should list the tags participating in the mandatory oneof:
	// e.g. mandatory_oneof: "['foo', 'bar']"
	MandatoryAnyof *string `protobuf:"bytes,21,opt,name=mandatory_anyof,json=mandatoryAnyof" json:"mandatory_anyof,omitempty"`
	// The attribute value must be equal to the value in this field.
	Value           []string `protobuf:"bytes,4,rep,name=value" json:"value,omitempty"`
	ValueCasei      []string `protobuf:"bytes,18,rep,name=value_casei,json=valueCasei" json:"value_casei,omitempty"`
	ValueRegex      *string  `protobuf:"bytes,15,opt,name=value_regex,json=valueRegex" json:"value_regex,omitempty"`
	ValueRegexCasei *string  `protobuf:"bytes,5,opt,name=value_regex_casei,json=valueRegexCasei" json:"value_regex_casei,omitempty"`
	ValueUrl        *UrlSpec `protobuf:"bytes,14,opt,name=value_url,json=valueUrl" json:"value_url,omitempty"`
	// validates against a list of properties (see PropertySpec).
	ValueProperties *PropertySpecList `protobuf:"bytes,11,opt,name=value_properties,json=valueProperties" json:"value_properties,omitempty"`
	// If set, the attribute value will be evaluated using the matching document
	// level CSS rules. This flag is used for `style` attributes. If
	// `value_doc_css` is set, only non-SVG css is applied. If `value_doc_css_svg`
	// is set, SVG-specific CSS rules are also allowed for this attribute value.
	ValueDocCss    *bool              `protobuf:"varint,27,opt,name=value_doc_css,json=valueDocCss" json:"value_doc_css,omitempty"`
	ValueDocSvgCss *bool              `protobuf:"varint,28,opt,name=value_doc_svg_css,json=valueDocSvgCss" json:"value_doc_svg_css,omitempty"`
	AddValueToSet  *AttrSpec_ValueSet `protobuf:"varint,25,opt,name=add_value_to_set,json=addValueToSet,enum=amp.validator.AttrSpec_ValueSet" json:"add_value_to_set,omitempty"`
	ValueOneofSet  *AttrSpec_ValueSet `protobuf:"varint,26,opt,name=value_oneof_set,json=valueOneofSet,enum=amp.validator.AttrSpec_ValueSet" json:"value_oneof_set,omitempty"`
	Trigger        *AttrTriggerSpec   `protobuf:"bytes,16,opt,name=trigger" json:"trigger,omitempty"`
	// If set, then the attribute value may not match this regex, which is
	// always applied case-insensitively and as a partial match.
	DisallowedValueRegex *string `protobuf:"bytes,6,opt,name=disallowed_value_regex,json=disallowedValueRegex" json:"disallowed_value_regex,omitempty"`
	// If set, generates a DEPRECATED_ATTR error with severity WARNING.
	// The value of the deprecation field indicates what to use instead,
	// e.g. the name of an attribute or tag.
	Deprecation *string `protobuf:"bytes,7,opt,name=deprecation" json:"deprecation,omitempty"`
	// If provided, a URL which links to the AMP HTML spec for this deprecation.
	DeprecationUrl *string `protobuf:"bytes,8,opt,name=deprecation_url,json=deprecationUrl" json:"deprecation_url,omitempty"`
	// Valid CSS declarations.
	CssDeclaration []*CssDeclaration `protobuf:"bytes,20,rep,name=css_declaration,json=cssDeclaration" json:"css_declaration,omitempty"`
	// If set true, the TagSpec containing this AttrSpec will be evaluated first
	// for any encountered tag which matches the tag name and this attribute spec.
	// May only be set for an AttrSpec where mandatory=true and type matches those
	// specified in the comments of DispatchKeyType above.
	DispatchKey *AttrSpec_DispatchKeyType `protobuf:"varint,13,opt,name=dispatch_key,json=dispatchKey,enum=amp.validator.AttrSpec_DispatchKeyType,def=0" json:"dispatch_key,omitempty"`
	// If set to true, the TagSpec containing this AttrSpec implicitly has this
	// attribute and the attribute is considered valid.
	Implicit *bool `protobuf:"varint,17,opt,name=implicit,def=0" json:"implicit,omitempty"`
	// If set, this attr is considered part of an amp extended component, and
	// requires that the named extended component script tag is present on the
	// page.
	RequiresExtension []string `protobuf:"bytes,19,rep,name=requires_extension,json=requiresExtension" json:"requires_extension,omitempty"`
	// If set, this attr is invalid unless the current tag has an ancestor
	// tag which set one or more of the required markers.
	RequiresAncestor     *AncestorMarker `protobuf:"bytes,22,opt,name=requires_ancestor,json=requiresAncestor" json:"requires_ancestor,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *AttrSpec) Reset()         { *m = AttrSpec{} }
func (m *AttrSpec) String() string { return proto.CompactTextString(m) }
func (*AttrSpec) ProtoMessage()    {}
func (*AttrSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{5}
}

func (m *AttrSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AttrSpec.Unmarshal(m, b)
}
func (m *AttrSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AttrSpec.Marshal(b, m, deterministic)
}
func (m *AttrSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttrSpec.Merge(m, src)
}
func (m *AttrSpec) XXX_Size() int {
	return xxx_messageInfo_AttrSpec.Size(m)
}
func (m *AttrSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AttrSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AttrSpec proto.InternalMessageInfo

const Default_AttrSpec_DispatchKey AttrSpec_DispatchKeyType = AttrSpec_NONE_DISPATCH
const Default_AttrSpec_Implicit bool = false

func (m *AttrSpec) GetEnabledBy() []string {
	if m != nil {
		return m.EnabledBy
	}
	return nil
}

func (m *AttrSpec) GetDisabledBy() []string {
	if m != nil {
		return m.DisabledBy
	}
	return nil
}

func (m *AttrSpec) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *AttrSpec) GetAlternativeNames() []string {
	if m != nil {
		return m.AlternativeNames
	}
	return nil
}

func (m *AttrSpec) GetMandatory() bool {
	if m != nil && m.Mandatory != nil {
		return *m.Mandatory
	}
	return false
}

func (m *AttrSpec) GetMandatoryOneof() string {
	if m != nil && m.MandatoryOneof != nil {
		return *m.MandatoryOneof
	}
	return ""
}

func (m *AttrSpec) GetMandatoryAnyof() string {
	if m != nil && m.MandatoryAnyof != nil {
		return *m.MandatoryAnyof
	}
	return ""
}

func (m *AttrSpec) GetValue() []string {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *AttrSpec) GetValueCasei() []string {
	if m != nil {
		return m.ValueCasei
	}
	return nil
}

func (m *AttrSpec) GetValueRegex() string {
	if m != nil && m.ValueRegex != nil {
		return *m.ValueRegex
	}
	return ""
}

func (m *AttrSpec) GetValueRegexCasei() string {
	if m != nil && m.ValueRegexCasei != nil {
		return *m.ValueRegexCasei
	}
	return ""
}

func (m *AttrSpec) GetValueUrl() *UrlSpec {
	if m != nil {
		return m.ValueUrl
	}
	return nil
}

func (m *AttrSpec) GetValueProperties() *PropertySpecList {
	if m != nil {
		return m.ValueProperties
	}
	return nil
}

func (m *AttrSpec) GetValueDocCss() bool {
	if m != nil && m.ValueDocCss != nil {
		return *m.ValueDocCss
	}
	return false
}

func (m *AttrSpec) GetValueDocSvgCss() bool {
	if m != nil && m.ValueDocSvgCss != nil {
		return *m.ValueDocSvgCss
	}
	return false
}

func (m *AttrSpec) GetAddValueToSet() AttrSpec_ValueSet {
	if m != nil && m.AddValueToSet != nil {
		return *m.AddValueToSet
	}
	return AttrSpec_UNKNOWN_VALUESET
}

func (m *AttrSpec) GetValueOneofSet() AttrSpec_ValueSet {
	if m != nil && m.ValueOneofSet != nil {
		return *m.ValueOneofSet
	}
	return AttrSpec_UNKNOWN_VALUESET
}

func (m *AttrSpec) GetTrigger() *AttrTriggerSpec {
	if m != nil {
		return m.Trigger
	}
	return nil
}

func (m *AttrSpec) GetDisallowedValueRegex() string {
	if m != nil && m.DisallowedValueRegex != nil {
		return *m.DisallowedValueRegex
	}
	return ""
}

func (m *AttrSpec) GetDeprecation() string {
	if m != nil && m.Deprecation != nil {
		return *m.Deprecation
	}
	return ""
}

func (m *AttrSpec) GetDeprecationUrl() string {
	if m != nil && m.DeprecationUrl != nil {
		return *m.DeprecationUrl
	}
	return ""
}

func (m *AttrSpec) GetCssDeclaration() []*CssDeclaration {
	if m != nil {
		return m.CssDeclaration
	}
	return nil
}

func (m *AttrSpec) GetDispatchKey() AttrSpec_DispatchKeyType {
	if m != nil && m.DispatchKey != nil {
		return *m.DispatchKey
	}
	return Default_AttrSpec_DispatchKey
}

func (m *AttrSpec) GetImplicit() bool {
	if m != nil && m.Implicit != nil {
		return *m.Implicit
	}
	return Default_AttrSpec_Implicit
}

func (m *AttrSpec) GetRequiresExtension() []string {
	if m != nil {
		return m.RequiresExtension
	}
	return nil
}

func (m *AttrSpec) GetRequiresAncestor() *AncestorMarker {
	if m != nil {
		return m.RequiresAncestor
	}
	return nil
}

// Some tags share several attributes, so they're identified by unique key
// (see the attr_lists map in ValidatorRules).
// NEXT AVAILABLE TAG: 3
type AttrList struct {
	Name                 *string     `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Attrs                []*AttrSpec `protobuf:"bytes,2,rep,name=attrs" json:"attrs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *AttrList) Reset()         { *m = AttrList{} }
func (m *AttrList) String() string { return proto.CompactTextString(m) }
func (*AttrList) ProtoMessage()    {}
func (*AttrList) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{6}
}

func (m *AttrList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AttrList.Unmarshal(m, b)
}
func (m *AttrList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AttrList.Marshal(b, m, deterministic)
}
func (m *AttrList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttrList.Merge(m, src)
}
func (m *AttrList) XXX_Size() int {
	return xxx_messageInfo_AttrList.Size(m)
}
func (m *AttrList) XXX_DiscardUnknown() {
	xxx_messageInfo_AttrList.DiscardUnknown(m)
}

var xxx_messageInfo_AttrList proto.InternalMessageInfo

func (m *AttrList) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *AttrList) GetAttrs() []*AttrSpec {
	if m != nil {
		return m.Attrs
	}
	return nil
}

// A list of allowed tags for descendants of any level (children, grandchildren,
// great-grandchildren, etc).
// NEXT AVAILABLE TAG: 3
type DescendantTagList struct {
	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Tag                  []string `protobuf:"bytes,2,rep,name=tag" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DescendantTagList) Reset()         { *m = DescendantTagList{} }
func (m *DescendantTagList) String() string { return proto.CompactTextString(m) }
func (*DescendantTagList) ProtoMessage()    {}
func (*DescendantTagList) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{7}
}

func (m *DescendantTagList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DescendantTagList.Unmarshal(m, b)
}
func (m *DescendantTagList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DescendantTagList.Marshal(b, m, deterministic)
}
func (m *DescendantTagList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DescendantTagList.Merge(m, src)
}
func (m *DescendantTagList) XXX_Size() int {
	return xxx_messageInfo_DescendantTagList.Size(m)
}
func (m *DescendantTagList) XXX_DiscardUnknown() {
	xxx_messageInfo_DescendantTagList.DiscardUnknown(m)
}

var xxx_messageInfo_DescendantTagList proto.InternalMessageInfo

func (m *DescendantTagList) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *DescendantTagList) GetTag() []string {
	if m != nil {
		return m.Tag
	}
	return nil
}

// Some style blocks share long lists of declarations, so they're identified by
// unique key.
// NEXT AVAILABLE TAG: 3
type DeclarationList struct {
	Name                 *string           `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Declaration          []*CssDeclaration `protobuf:"bytes,2,rep,name=declaration" json:"declaration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *DeclarationList) Reset()         { *m = DeclarationList{} }
func (m *DeclarationList) String() string { return proto.CompactTextString(m) }
func (*DeclarationList) ProtoMessage()    {}
func (*DeclarationList) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{8}
}

func (m *DeclarationList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeclarationList.Unmarshal(m, b)
}
func (m *DeclarationList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeclarationList.Marshal(b, m, deterministic)
}
func (m *DeclarationList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeclarationList.Merge(m, src)
}
func (m *DeclarationList) XXX_Size() int {
	return xxx_messageInfo_DeclarationList.Size(m)
}
func (m *DeclarationList) XXX_DiscardUnknown() {
	xxx_messageInfo_DeclarationList.DiscardUnknown(m)
}

var xxx_messageInfo_DeclarationList proto.InternalMessageInfo

func (m *DeclarationList) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *DeclarationList) GetDeclaration() []*CssDeclaration {
	if m != nil {
		return m.Declaration
	}
	return nil
}

// Regex which, if matches the cdata of a tag, causes the tag validation to
// fail.
// NEXT AVAILABLE TAG: 3
type DisallowedCDataRegex struct {
	// Syntax is partial match, use ^ and $ if you want global match.
	Regex                *string  `protobuf:"bytes,1,opt,name=regex" json:"regex,omitempty"`
	ErrorMessage         *string  `protobuf:"bytes,2,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DisallowedCDataRegex) Reset()         { *m = DisallowedCDataRegex{} }
func (m *DisallowedCDataRegex) String() string { return proto.CompactTextString(m) }
func (*DisallowedCDataRegex) ProtoMessage()    {}
func (*DisallowedCDataRegex) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{9}
}

func (m *DisallowedCDataRegex) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DisallowedCDataRegex.Unmarshal(m, b)
}
func (m *DisallowedCDataRegex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DisallowedCDataRegex.Marshal(b, m, deterministic)
}
func (m *DisallowedCDataRegex) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DisallowedCDataRegex.Merge(m, src)
}
func (m *DisallowedCDataRegex) XXX_Size() int {
	return xxx_messageInfo_DisallowedCDataRegex.Size(m)
}
func (m *DisallowedCDataRegex) XXX_DiscardUnknown() {
	xxx_messageInfo_DisallowedCDataRegex.DiscardUnknown(m)
}

var xxx_messageInfo_DisallowedCDataRegex proto.InternalMessageInfo

func (m *DisallowedCDataRegex) GetRegex() string {
	if m != nil && m.Regex != nil {
		return *m.Regex
	}
	return ""
}

func (m *DisallowedCDataRegex) GetErrorMessage() string {
	if m != nil && m.ErrorMessage != nil {
		return *m.ErrorMessage
	}
	return ""
}

// This spec is used when parsing a media query inside a CSS @media rule.
// NEXT AVAILABLE TAG: 5
type MediaQuerySpec struct {
	// If issues_as_error is true, then parsing errors and invalid
	// types / features will be treated as validator errors, otherwise warnings.
	IssuesAsError *bool `protobuf:"varint,1,opt,name=issues_as_error,json=issuesAsError,def=0" json:"issues_as_error,omitempty"`
	// These are the media query types and features allowed within the stylesheet.
	// http://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries#Syntax
	Type                 []string `protobuf:"bytes,2,rep,name=type" json:"type,omitempty"`
	Feature              []string `protobuf:"bytes,3,rep,name=feature" json:"feature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MediaQuerySpec) Reset()         { *m = MediaQuerySpec{} }
func (m *MediaQuerySpec) String() string { return proto.CompactTextString(m) }
func (*MediaQuerySpec) ProtoMessage()    {}
func (*MediaQuerySpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{10}
}

func (m *MediaQuerySpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MediaQuerySpec.Unmarshal(m, b)
}
func (m *MediaQuerySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MediaQuerySpec.Marshal(b, m, deterministic)
}
func (m *MediaQuerySpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MediaQuerySpec.Merge(m, src)
}
func (m *MediaQuerySpec) XXX_Size() int {
	return xxx_messageInfo_MediaQuerySpec.Size(m)
}
func (m *MediaQuerySpec) XXX_DiscardUnknown() {
	xxx_messageInfo_MediaQuerySpec.DiscardUnknown(m)
}

var xxx_messageInfo_MediaQuerySpec proto.InternalMessageInfo

const Default_MediaQuerySpec_IssuesAsError bool = false

func (m *MediaQuerySpec) GetIssuesAsError() bool {
	if m != nil && m.IssuesAsError != nil {
		return *m.IssuesAsError
	}
	return Default_MediaQuerySpec_IssuesAsError
}

func (m *MediaQuerySpec) GetType() []string {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *MediaQuerySpec) GetFeature() []string {
	if m != nil {
		return m.Feature
	}
	return nil
}

// This spec is used when parsing a CSS selector group as the prelude of a CSS
// qualified rule. For example "div.foo span.bar". If no SelectorSpec is
// provided, the selector groups are unconstrained.
// NEXT AVAILABLE TAG: 4
type SelectorSpec struct {
	// Allowed attribute selector names. For example `foo` in the selector
	// `.a[foo=bar]`.
	AttributeName []string `protobuf:"bytes,1,rep,name=attribute_name,json=attributeName" json:"attribute_name,omitempty"`
	// Allowed pseudo class names. For example `checked` in `.a:checked`.
	PseudoClass []string `protobuf:"bytes,2,rep,name=pseudo_class,json=pseudoClass" json:"pseudo_class,omitempty"`
	// Allowed pseudo element names. For example `before` in `.a::before`.
	PseudoElement        []string `protobuf:"bytes,3,rep,name=pseudo_element,json=pseudoElement" json:"pseudo_element,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SelectorSpec) Reset()         { *m = SelectorSpec{} }
func (m *SelectorSpec) String() string { return proto.CompactTextString(m) }
func (*SelectorSpec) ProtoMessage()    {}
func (*SelectorSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{11}
}

func (m *SelectorSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SelectorSpec.Unmarshal(m, b)
}
func (m *SelectorSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SelectorSpec.Marshal(b, m, deterministic)
}
func (m *SelectorSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SelectorSpec.Merge(m, src)
}
func (m *SelectorSpec) XXX_Size() int {
	return xxx_messageInfo_SelectorSpec.Size(m)
}
func (m *SelectorSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_SelectorSpec.DiscardUnknown(m)
}

var xxx_messageInfo_SelectorSpec proto.InternalMessageInfo

func (m *SelectorSpec) GetAttributeName() []string {
	if m != nil {
		return m.AttributeName
	}
	return nil
}

func (m *SelectorSpec) GetPseudoClass() []string {
	if m != nil {
		return m.PseudoClass
	}
	return nil
}

func (m *SelectorSpec) GetPseudoElement() []string {
	if m != nil {
		return m.PseudoElement
	}
	return nil
}

// This spec is used by our CSS parser to determine what AT rules are allowed
// in the CSS spec. The term 'rule' here refers to the AT Rule in CSS, not a
// validation rule.
// NEXT AVAILABLE TAG: 4
type AtRuleSpec struct {
	// Name of the AT rule to parse. Do not include the '@' symbol (e.g. '@media'
	// should be encoded as 'media'.
	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// A MediaQuerySpec may only be set for an AtRuleSpec with the name
	// "media". If not set, media queries will be left unparsed, so no errors or
	// warnings about them will be reported.
	MediaQuerySpec       *MediaQuerySpec `protobuf:"bytes,3,opt,name=media_query_spec,json=mediaQuerySpec" json:"media_query_spec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *AtRuleSpec) Reset()         { *m = AtRuleSpec{} }
func (m *AtRuleSpec) String() string { return proto.CompactTextString(m) }
func (*AtRuleSpec) ProtoMessage()    {}
func (*AtRuleSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{12}
}

func (m *AtRuleSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AtRuleSpec.Unmarshal(m, b)
}
func (m *AtRuleSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AtRuleSpec.Marshal(b, m, deterministic)
}
func (m *AtRuleSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AtRuleSpec.Merge(m, src)
}
func (m *AtRuleSpec) XXX_Size() int {
	return xxx_messageInfo_AtRuleSpec.Size(m)
}
func (m *AtRuleSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_AtRuleSpec.DiscardUnknown(m)
}

var xxx_messageInfo_AtRuleSpec proto.InternalMessageInfo

func (m *AtRuleSpec) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *AtRuleSpec) GetMediaQuerySpec() *MediaQuerySpec {
	if m != nil {
		return m.MediaQuerySpec
	}
	return nil
}

// NEXT AVAILABLE TAG: 10
type CssSpec struct {
	// Spec for how to parse CSS AT rules, one per AT rule. Must not contain
	// duplicate names, and must contain at least one entry for the default.
	AtRuleSpec []*AtRuleSpec `protobuf:"bytes,1,rep,name=at_rule_spec,json=atRuleSpec" json:"at_rule_spec,omitempty"`
	// Enables checks specific to the draft A4A specification.
	// TODO(powdercloud): Make this more generic.
	ValidateAmp4Ads *bool `protobuf:"varint,5,opt,name=validate_amp4ads,json=validateAmp4ads" json:"validate_amp4ads,omitempty"`
	// Enables checks specific to the style[keyframes] specification.
	// TODO(chenshay): Make this more generic.
	ValidateKeyframes *bool `protobuf:"varint,6,opt,name=validate_keyframes,json=validateKeyframes" json:"validate_keyframes,omitempty"`
	// Any declaration listed here are allowed.
	Declaration []string `protobuf:"bytes,7,rep,name=declaration" json:"declaration,omitempty"`
	// If fase, declarations tagged with `!important` are considered errors.
	// Most AMP stylesheets disallow `!important` to reserve this override
	// for AMP's own styles.
	AllowImportant       *bool         `protobuf:"varint,8,opt,name=allow_important,json=allowImportant,def=0" json:"allow_important,omitempty"`
	SelectorSpec         *SelectorSpec `protobuf:"bytes,9,opt,name=selector_spec,json=selectorSpec" json:"selector_spec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *CssSpec) Reset()         { *m = CssSpec{} }
func (m *CssSpec) String() string { return proto.CompactTextString(m) }
func (*CssSpec) ProtoMessage()    {}
func (*CssSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{13}
}

func (m *CssSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CssSpec.Unmarshal(m, b)
}
func (m *CssSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CssSpec.Marshal(b, m, deterministic)
}
func (m *CssSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CssSpec.Merge(m, src)
}
func (m *CssSpec) XXX_Size() int {
	return xxx_messageInfo_CssSpec.Size(m)
}
func (m *CssSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_CssSpec.DiscardUnknown(m)
}

var xxx_messageInfo_CssSpec proto.InternalMessageInfo

const Default_CssSpec_AllowImportant bool = false

func (m *CssSpec) GetAtRuleSpec() []*AtRuleSpec {
	if m != nil {
		return m.AtRuleSpec
	}
	return nil
}

func (m *CssSpec) GetValidateAmp4Ads() bool {
	if m != nil && m.ValidateAmp4Ads != nil {
		return *m.ValidateAmp4Ads
	}
	return false
}

func (m *CssSpec) GetValidateKeyframes() bool {
	if m != nil && m.ValidateKeyframes != nil {
		return *m.ValidateKeyframes
	}
	return false
}

func (m *CssSpec) GetDeclaration() []string {
	if m != nil {
		return m.Declaration
	}
	return nil
}

func (m *CssSpec) GetAllowImportant() bool {
	if m != nil && m.AllowImportant != nil {
		return *m.AllowImportant
	}
	return Default_CssSpec_AllowImportant
}

func (m *CssSpec) GetSelectorSpec() *SelectorSpec {
	if m != nil {
		return m.SelectorSpec
	}
	return nil
}

// NEXT AVAILABLE TAG: 12
type CdataSpec struct {
	// If set, the cdata contents cannot be greater than this length, in bytes. A
	// value of -2 (default) indicates that there is no limit (unlimited). A value
	// of -1 will always cause validation failure on match. -1 is used to
	// implement the `amp-custom-length-check` attribute:
	// (https://github.com/ampproject/amphtml/issues/22315#issuecomment-496681165)
	MaxBytes *int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,def=-2" json:"max_bytes,omitempty"`
	// If provided, a URL which linking to a section / sentence in the
	// AMP HTML spec.
	MaxBytesSpecUrl *string `protobuf:"bytes,2,opt,name=max_bytes_spec_url,json=maxBytesSpecUrl" json:"max_bytes_spec_url,omitempty"`
	// If non-empty, the text between the start / end tag must match this value.
	MandatoryCdata *string `protobuf:"bytes,3,opt,name=mandatory_cdata,json=mandatoryCdata" json:"mandatory_cdata,omitempty"`
	// If non-empty, the text between the start / end tag must match this regex.
	CdataRegex *string `protobuf:"bytes,6,opt,name=cdata_regex,json=cdataRegex" json:"cdata_regex,omitempty"`
	// If at least one CssSpec is provided, this cdata field will be parsed
	// as CSS3, and any parsing errors will become validation errors.
	CssSpec *CssSpec `protobuf:"bytes,7,opt,name=css_spec,json=cssSpec" json:"css_spec,omitempty"`
	// If set to true, then only whitespace may be in the cdata contents.
	// This is useful for script tags that reference extensions etc.
	WhitespaceOnly *bool `protobuf:"varint,8,opt,name=whitespace_only,json=whitespaceOnly" json:"whitespace_only,omitempty"`
	// If any of these regexes match, then this cdata spec does not validate.
	DisallowedCdataRegex []*DisallowedCDataRegex `protobuf:"bytes,4,rep,name=disallowed_cdata_regex,json=disallowedCdataRegex" json:"disallowed_cdata_regex,omitempty"`
	// If true, the contents of this tag's CDATA text will be counted against the
	// document level DocCssSpec CSS lengths.
	DocCssBytes          *bool    `protobuf:"varint,11,opt,name=doc_css_bytes,json=docCssBytes" json:"doc_css_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CdataSpec) Reset()         { *m = CdataSpec{} }
func (m *CdataSpec) String() string { return proto.CompactTextString(m) }
func (*CdataSpec) ProtoMessage()    {}
func (*CdataSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{14}
}

func (m *CdataSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CdataSpec.Unmarshal(m, b)
}
func (m *CdataSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CdataSpec.Marshal(b, m, deterministic)
}
func (m *CdataSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CdataSpec.Merge(m, src)
}
func (m *CdataSpec) XXX_Size() int {
	return xxx_messageInfo_CdataSpec.Size(m)
}
func (m *CdataSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_CdataSpec.DiscardUnknown(m)
}

var xxx_messageInfo_CdataSpec proto.InternalMessageInfo

const Default_CdataSpec_MaxBytes int32 = -2

func (m *CdataSpec) GetMaxBytes() int32 {
	if m != nil && m.MaxBytes != nil {
		return *m.MaxBytes
	}
	return Default_CdataSpec_MaxBytes
}

func (m *CdataSpec) GetMaxBytesSpecUrl() string {
	if m != nil && m.MaxBytesSpecUrl != nil {
		return *m.MaxBytesSpecUrl
	}
	return ""
}

func (m *CdataSpec) GetMandatoryCdata() string {
	if m != nil && m.MandatoryCdata != nil {
		return *m.MandatoryCdata
	}
	return ""
}

func (m *CdataSpec) GetCdataRegex() string {
	if m != nil && m.CdataRegex != nil {
		return *m.CdataRegex
	}
	return ""
}

func (m *CdataSpec) GetCssSpec() *CssSpec {
	if m != nil {
		return m.CssSpec
	}
	return nil
}

func (m *CdataSpec) GetWhitespaceOnly() bool {
	if m != nil && m.WhitespaceOnly != nil {
		return *m.WhitespaceOnly
	}
	return false
}

func (m *CdataSpec) GetDisallowedCdataRegex() []*DisallowedCDataRegex {
	if m != nil {
		return m.DisallowedCdataRegex
	}
	return nil
}

func (m *CdataSpec) GetDocCssBytes() bool {
	if m != nil && m.DocCssBytes != nil {
		return *m.DocCssBytes
	}
	return false
}

// Specifies which AMP Layouts are supported by a given element.
// For the purpose of the validator, this specifies which
// values for layout, height, and width attributes are allowed. Also see
// https://github.com/ampproject/amphtml/blob/main/spec/amp-html-layout.md
// TODO(johannes): Make the error messages around layouts better. This
// may require revamping the documentation for elements and/or the above spec,
// so that a user gets more clearly informed about which layouts are
// applicable to a given tag, what happens when layout attribute or other
// attributes are not set, etc.
// NEXT AVAILABLE TAG: 4
type AmpLayout struct {
	// Specifies which layouts are supported by this element.
	SupportedLayouts []AmpLayout_Layout `protobuf:"varint,1,rep,name=supported_layouts,json=supportedLayouts,enum=amp.validator.AmpLayout_Layout" json:"supported_layouts,omitempty"`
	// Specifies whether this element has default dimensions. This corresponds
	// to being allowlisted in naturalDimensions_ in
	// https://github.com/ampproject/amphtml/blob/main/src/layout.js.
	DefinesDefaultWidth  *bool    `protobuf:"varint,2,opt,name=defines_default_width,json=definesDefaultWidth" json:"defines_default_width,omitempty"`
	DefinesDefaultHeight *bool    `protobuf:"varint,3,opt,name=defines_default_height,json=definesDefaultHeight" json:"defines_default_height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AmpLayout) Reset()         { *m = AmpLayout{} }
func (m *AmpLayout) String() string { return proto.CompactTextString(m) }
func (*AmpLayout) ProtoMessage()    {}
func (*AmpLayout) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{15}
}

func (m *AmpLayout) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AmpLayout.Unmarshal(m, b)
}
func (m *AmpLayout) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AmpLayout.Marshal(b, m, deterministic)
}
func (m *AmpLayout) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AmpLayout.Merge(m, src)
}
func (m *AmpLayout) XXX_Size() int {
	return xxx_messageInfo_AmpLayout.Size(m)
}
func (m *AmpLayout) XXX_DiscardUnknown() {
	xxx_messageInfo_AmpLayout.DiscardUnknown(m)
}

var xxx_messageInfo_AmpLayout proto.InternalMessageInfo

func (m *AmpLayout) GetSupportedLayouts() []AmpLayout_Layout {
	if m != nil {
		return m.SupportedLayouts
	}
	return nil
}

func (m *AmpLayout) GetDefinesDefaultWidth() bool {
	if m != nil && m.DefinesDefaultWidth != nil {
		return *m.DefinesDefaultWidth
	}
	return false
}

func (m *AmpLayout) GetDefinesDefaultHeight() bool {
	if m != nil && m.DefinesDefaultHeight != nil {
		return *m.DefinesDefaultHeight
	}
	return false
}

// An AncestorMarker is a state maintained on the stack of matching tags.
// When a TagSpec with an AncestorMarker matches, this Marker is placed on the
// stack until the matched html tag is popped from the stack. Other rules may be
// triggered by the presence of a specific AncestorMarker on the stack.
// NEXT AVAILABLE TAG: 2
type AncestorMarker struct {
	Marker               []AncestorMarker_Marker `protobuf:"varint,1,rep,name=marker,enum=amp.validator.AncestorMarker_Marker" json:"marker,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *AncestorMarker) Reset()         { *m = AncestorMarker{} }
func (m *AncestorMarker) String() string { return proto.CompactTextString(m) }
func (*AncestorMarker) ProtoMessage()    {}
func (*AncestorMarker) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{16}
}

func (m *AncestorMarker) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AncestorMarker.Unmarshal(m, b)
}
func (m *AncestorMarker) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AncestorMarker.Marshal(b, m, deterministic)
}
func (m *AncestorMarker) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AncestorMarker.Merge(m, src)
}
func (m *AncestorMarker) XXX_Size() int {
	return xxx_messageInfo_AncestorMarker.Size(m)
}
func (m *AncestorMarker) XXX_DiscardUnknown() {
	xxx_messageInfo_AncestorMarker.DiscardUnknown(m)
}

var xxx_messageInfo_AncestorMarker proto.InternalMessageInfo

func (m *AncestorMarker) GetMarker() []AncestorMarker_Marker {
	if m != nil {
		return m.Marker
	}
	return nil
}

// TagSpec::child_tags uses this configuration to specify which child tags
// are expected for a specific tag.
//
// Matching child tags is done by tag name, while the parent is
// matched by TagSpec. The reason for this is that matching by tag
// spec name would produce less useful error messages, because we want
// to be able to produce a good message even if the tag spec name
// could not be determined because the enclosed child tag is invalid
// (no TagSpec matches). By doing a tag name match, we can produce a
// reasonable error regardless if a child tag was misplaced.
// NEXT AVAILABLE TAG: 5
type ChildTagSpec struct {
	// Unless set to -1 (the default), the parent tag must have exactly
	// |mandatory_num_child_tags| immediate child tags.
	MandatoryNumChildTags *int32 `protobuf:"varint,1,opt,name=mandatory_num_child_tags,json=mandatoryNumChildTags,def=-1" json:"mandatory_num_child_tags,omitempty"`
	// If at least one tag name is specified, then the first child of the
	// parent tag must have one of the provided names.
	FirstChildTagNameOneof []string `protobuf:"bytes,2,rep,name=first_child_tag_name_oneof,json=firstChildTagNameOneof" json:"first_child_tag_name_oneof,omitempty"`
	// If at least one tag name is specified, then the child tags of
	// the parent tag must have one of the provided tag names.
	ChildTagNameOneof []string `protobuf:"bytes,3,rep,name=child_tag_name_oneof,json=childTagNameOneof" json:"child_tag_name_oneof,omitempty"`
	// Unless set to -1 (the default), the parent tag must have a minimum of
	// |mandatory_min_num_child_tags| immediate child tags.
	MandatoryMinNumChildTags *int32   `protobuf:"varint,4,opt,name=mandatory_min_num_child_tags,json=mandatoryMinNumChildTags,def=-1" json:"mandatory_min_num_child_tags,omitempty"`
	XXX_NoUnkeyedLiteral     struct{} `json:"-"`
	XXX_unrecognized         []byte   `json:"-"`
	XXX_sizecache            int32    `json:"-"`
}

func (m *ChildTagSpec) Reset()         { *m = ChildTagSpec{} }
func (m *ChildTagSpec) String() string { return proto.CompactTextString(m) }
func (*ChildTagSpec) ProtoMessage()    {}
func (*ChildTagSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{17}
}

func (m *ChildTagSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChildTagSpec.Unmarshal(m, b)
}
func (m *ChildTagSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChildTagSpec.Marshal(b, m, deterministic)
}
func (m *ChildTagSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChildTagSpec.Merge(m, src)
}
func (m *ChildTagSpec) XXX_Size() int {
	return xxx_messageInfo_ChildTagSpec.Size(m)
}
func (m *ChildTagSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ChildTagSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ChildTagSpec proto.InternalMessageInfo

const Default_ChildTagSpec_MandatoryNumChildTags int32 = -1
const Default_ChildTagSpec_MandatoryMinNumChildTags int32 = -1

func (m *ChildTagSpec) GetMandatoryNumChildTags() int32 {
	if m != nil && m.MandatoryNumChildTags != nil {
		return *m.MandatoryNumChildTags
	}
	return Default_ChildTagSpec_MandatoryNumChildTags
}

func (m *ChildTagSpec) GetFirstChildTagNameOneof() []string {
	if m != nil {
		return m.FirstChildTagNameOneof
	}
	return nil
}

func (m *ChildTagSpec) GetChildTagNameOneof() []string {
	if m != nil {
		return m.ChildTagNameOneof
	}
	return nil
}

func (m *ChildTagSpec) GetMandatoryMinNumChildTags() int32 {
	if m != nil && m.MandatoryMinNumChildTags != nil {
		return *m.MandatoryMinNumChildTags
	}
	return Default_ChildTagSpec_MandatoryMinNumChildTags
}

// TagSpecs and reference points.
//
// Any TagSpec may define a list of reference points via the
// TagSpec::reference_points field. These reference points specify how
// DOM elements that are children of this parent tag fulfill particular
// functionality. For instance, a widget (implemented as an AMP tag) may
// require a login reference point. Any valid AMP tag would be allowed,
// whether it's a clickable DIV or an AMP-IMG or a BUTTON, so long as
// it *also* conforms to the reference point specification. This
// specification is a TagSpec which does not define a name (the
// name is set to the special value '$REFERENCE_POINT'), but rather
// identifies the reference point with AttrSpec requirements. For instance,
// the login reference point may require that there be a login attribute,
// or some end-point attribute with a URL, or similar.
// Therefore, for any child tags of a tag that defines reference points,
// they are first matched against these reference points, and only
// then are they validated as regular tags against the TagSpecs that are
// not reference points while their reference point attributes are skipped.
// The complexity of this mechanism is unfortunate but reduces the markup
// required and makes CSS styling more convenient. Please see
// the amp-live-list specification for an example.
// NEXT AVAILABLE TAG: 4
type ReferencePoint struct {
	// A tag spec identified by its TagSpec::spec_name which specifies how
	// a specific functionality for the parent tag is assigned.
	TagSpecName *string `protobuf:"bytes,1,opt,name=tag_spec_name,json=tagSpecName" json:"tag_spec_name,omitempty"`
	// At least one of the child tags of the parent defining this
	// reference point must match it.
	Mandatory *bool `protobuf:"varint,2,opt,name=mandatory" json:"mandatory,omitempty"`
	// At most one of the child tags of the parent defining this
	// reference point must match it.
	Unique               *bool    `protobuf:"varint,3,opt,name=unique" json:"unique,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReferencePoint) Reset()         { *m = ReferencePoint{} }
func (m *ReferencePoint) String() string { return proto.CompactTextString(m) }
func (*ReferencePoint) ProtoMessage()    {}
func (*ReferencePoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{18}
}

func (m *ReferencePoint) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReferencePoint.Unmarshal(m, b)
}
func (m *ReferencePoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReferencePoint.Marshal(b, m, deterministic)
}
func (m *ReferencePoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReferencePoint.Merge(m, src)
}
func (m *ReferencePoint) XXX_Size() int {
	return xxx_messageInfo_ReferencePoint.Size(m)
}
func (m *ReferencePoint) XXX_DiscardUnknown() {
	xxx_messageInfo_ReferencePoint.DiscardUnknown(m)
}

var xxx_messageInfo_ReferencePoint proto.InternalMessageInfo

func (m *ReferencePoint) GetTagSpecName() string {
	if m != nil && m.TagSpecName != nil {
		return *m.TagSpecName
	}
	return ""
}

func (m *ReferencePoint) GetMandatory() bool {
	if m != nil && m.Mandatory != nil {
		return *m.Mandatory
	}
	return false
}

func (m *ReferencePoint) GetUnique() bool {
	if m != nil && m.Unique != nil {
		return *m.Unique
	}
	return false
}

// Specs specific to AMP Extensions. This is a field within TagSpec that
// replaces the standard tagspec list of attributes, requirements, etc.
// NEXT AVAILABLE TAG: 9
type ExtensionSpec struct {
	// e.g. "amp-video". This is used both as the attribute value for the
	// 'custom-element' attribute value as well as part of the 'src' attribute
	// value.
	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// e.g. "0.1", "1.0", "latest".
	Version []string `protobuf:"bytes,2,rep,name=version" json:"version,omitempty"`
	// If multiple TagSpecs for the same extension exist, separated by version,
	// specify a version_name string to disambiguate their spec_names. For
	// example, "v1.0" or "v0.1-0.2".
	VersionName *string `protobuf:"bytes,9,opt,name=version_name,json=versionName" json:"version_name,omitempty"`
	// deprecated_version must be a strict subset of version. If the version
	// matches a deprecated_version, validation will emit a warning.
	DeprecatedVersion []string                     `protobuf:"bytes,3,rep,name=deprecated_version,json=deprecatedVersion" json:"deprecated_version,omitempty"`
	ExtensionType     *ExtensionSpec_ExtensionType `protobuf:"varint,8,opt,name=extension_type,json=extensionType,enum=amp.validator.ExtensionSpec_ExtensionType,def=1" json:"extension_type,omitempty"`
	// For older tags, we did not originally require that the tag only be included
	// once, so those tags are exempted from the multiple inclusion ban.
	DeprecatedAllowDuplicates *bool                                    `protobuf:"varint,6,opt,name=deprecated_allow_duplicates,json=deprecatedAllowDuplicates,def=0" json:"deprecated_allow_duplicates,omitempty"`
	RequiresUsage             *ExtensionSpec_ExtensionUsageRequirement `protobuf:"varint,7,opt,name=requires_usage,json=requiresUsage,enum=amp.validator.ExtensionSpec_ExtensionUsageRequirement,def=1" json:"requires_usage,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                                 `json:"-"`
	XXX_unrecognized          []byte                                   `json:"-"`
	XXX_sizecache             int32                                    `json:"-"`
}

func (m *ExtensionSpec) Reset()         { *m = ExtensionSpec{} }
func (m *ExtensionSpec) String() string { return proto.CompactTextString(m) }
func (*ExtensionSpec) ProtoMessage()    {}
func (*ExtensionSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{19}
}

func (m *ExtensionSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExtensionSpec.Unmarshal(m, b)
}
func (m *ExtensionSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExtensionSpec.Marshal(b, m, deterministic)
}
func (m *ExtensionSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtensionSpec.Merge(m, src)
}
func (m *ExtensionSpec) XXX_Size() int {
	return xxx_messageInfo_ExtensionSpec.Size(m)
}
func (m *ExtensionSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtensionSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ExtensionSpec proto.InternalMessageInfo

const Default_ExtensionSpec_ExtensionType ExtensionSpec_ExtensionType = ExtensionSpec_CUSTOM_ELEMENT
const Default_ExtensionSpec_DeprecatedAllowDuplicates bool = false
const Default_ExtensionSpec_RequiresUsage ExtensionSpec_ExtensionUsageRequirement = ExtensionSpec_ERROR

func (m *ExtensionSpec) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *ExtensionSpec) GetVersion() []string {
	if m != nil {
		return m.Version
	}
	return nil
}

func (m *ExtensionSpec) GetVersionName() string {
	if m != nil && m.VersionName != nil {
		return *m.VersionName
	}
	return ""
}

func (m *ExtensionSpec) GetDeprecatedVersion() []string {
	if m != nil {
		return m.DeprecatedVersion
	}
	return nil
}

func (m *ExtensionSpec) GetExtensionType() ExtensionSpec_ExtensionType {
	if m != nil && m.ExtensionType != nil {
		return *m.ExtensionType
	}
	return Default_ExtensionSpec_ExtensionType
}

func (m *ExtensionSpec) GetDeprecatedAllowDuplicates() bool {
	if m != nil && m.DeprecatedAllowDuplicates != nil {
		return *m.DeprecatedAllowDuplicates
	}
	return Default_ExtensionSpec_DeprecatedAllowDuplicates
}

func (m *ExtensionSpec) GetRequiresUsage() ExtensionSpec_ExtensionUsageRequirement {
	if m != nil && m.RequiresUsage != nil {
		return *m.RequiresUsage
	}
	return Default_ExtensionSpec_RequiresUsage
}

// The HtmlFormat is the declared format in the top-level html tag, which
// prescribes a particular set of validation rules. This should be kept in sync
// with Request.HtmlFormat in
// github.com/ampproject/amppackager/transformer/request/request.proto.
type HtmlFormat struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *HtmlFormat) Reset()         { *m = HtmlFormat{} }
func (m *HtmlFormat) String() string { return proto.CompactTextString(m) }
func (*HtmlFormat) ProtoMessage()    {}
func (*HtmlFormat) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{20}
}

func (m *HtmlFormat) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HtmlFormat.Unmarshal(m, b)
}
func (m *HtmlFormat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HtmlFormat.Marshal(b, m, deterministic)
}
func (m *HtmlFormat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HtmlFormat.Merge(m, src)
}
func (m *HtmlFormat) XXX_Size() int {
	return xxx_messageInfo_HtmlFormat.Size(m)
}
func (m *HtmlFormat) XXX_DiscardUnknown() {
	xxx_messageInfo_HtmlFormat.DiscardUnknown(m)
}

var xxx_messageInfo_HtmlFormat proto.InternalMessageInfo

// Tags that are not covered by at least one of these specs are disallowed.
// Some tags are mandatory. Note that the tag name is not unique, that is,
// there can be multiple tag specs covering the same name, e.g., for
// multiple meta tags (with different attributes).
// NEXT AVAILABLE TAG: 40
type TagSpec struct {
	// The html_format field tells the validator for which html formats
	// (ie: (<html ⚡> vs <html a4⚡>) this HTML TagSpec is allowed to validate.
	// The repeated field is not allowed to be empty, it must have at least one
	// HtmlFormat.
	HtmlFormat []HtmlFormat_Code `protobuf:"varint,21,rep,name=html_format,json=htmlFormat,enum=amp.validator.HtmlFormat_Code" json:"html_format,omitempty"`
	// If provided, the Type Identifier(s) that either enable or disable
	// this TagSpec. If a Type Identifier is in `enabled_by` then this
	// TagSpec will be used in validating parsed documents which include that Type
	// Identifier. If a Type Identifier is in `disabled_by` then this
	// TagSpec will not be used in validating parsed documents which include that
	// Type Identifier. A TagSpec can not have both `enabled_by` and `disabled_by`
	// set.
	EnabledBy  []string `protobuf:"bytes,35,rep,name=enabled_by,json=enabledBy" json:"enabled_by,omitempty"`
	DisabledBy []string `protobuf:"bytes,36,rep,name=disabled_by,json=disabledBy" json:"disabled_by,omitempty"`
	// Use UPPER-CASE tag names only. If adding the same tag twice, then they must
	// also have a spec_name string which is unique throughout all detail.
	// Note: "$REFERENCE_POINT" is a special tag_name value.
	//       Reference points are partial tag specs which don't have a defined
	//       tag_name.
	TagName *string `protobuf:"bytes,1,opt,name=tag_name,json=tagName" json:"tag_name,omitempty"`
	// If provided, the spec_name must be unique within the validator
	// rules. This string forms a a unique id for this TagSpec. If not set, the
	// tag_name field is used as the unique id. This string is not used in error
	// messages, see descriptive_name for that.
	SpecName *string `protobuf:"bytes,2,opt,name=spec_name,json=specName" json:"spec_name,omitempty"`
	// If `tag_name` is not a sufficient descriptor for error messages having to
	// do with this tag spec, provide a `descriptive_name` value, which if present
	// will be used in place of `tag_name`. Typically `descriptive_name` should
	// include the tag_name in it, and should avoid using < and > in case
	// downstream libraries of the validator fail to properly HTML escape rendered
	// error strings.
	DescriptiveName *string          `protobuf:"bytes,39,opt,name=descriptive_name,json=descriptiveName" json:"descriptive_name,omitempty"`
	NamedId         *TagSpec_NamedId `protobuf:"varint,33,opt,name=named_id,json=namedId,enum=amp.validator.TagSpec_NamedId,def=0" json:"named_id,omitempty"`
	// If provided, this is a SCRIPT tag defining an amp custom element
	// extension. The other fields, such as expected attributes, will be
	// validated by the extension spec rules.
	ExtensionSpec *ExtensionSpec `protobuf:"bytes,27,opt,name=extension_spec,json=extensionSpec" json:"extension_spec,omitempty"`
	// If set, this tag is considered part of an amp extended component, and
	// requires that the named extended component script tag is present on the
	// page.
	RequiresExtension []string `protobuf:"bytes,28,rep,name=requires_extension,json=requiresExtension" json:"requires_extension,omitempty"`
	// If true, a tag conforming to this tag spec must occur at least once
	// within the document.
	Mandatory *bool `protobuf:"varint,3,opt,name=mandatory" json:"mandatory,omitempty"`
	// A string identifying that this tag belongs to a set of alternative
	// choices from which at least one needs to be satisfied.
	MandatoryAlternatives *string `protobuf:"bytes,4,opt,name=mandatory_alternatives,json=mandatoryAlternatives" json:"mandatory_alternatives,omitempty"`
	// If true, a tag conforming to this tag spec may occur at most once within
	// the document.
	Unique *bool `protobuf:"varint,5,opt,name=unique" json:"unique,omitempty"`
	// If true, a tag conforming to this tag spec should occur at most once within
	// the document. That is, unlike for unique, we'll emit a warning.
	UniqueWarning *bool `protobuf:"varint,25,opt,name=unique_warning,json=uniqueWarning" json:"unique_warning,omitempty"`
	// If set to "$ROOT", this tag must be the root tag.
	// If set to any other string, the tag must be the direct child of the
	//   specified mandatory parent tag.
	MandatoryParent *string `protobuf:"bytes,6,opt,name=mandatory_parent,json=mandatoryParent" json:"mandatory_parent,omitempty"`
	// If set, the tag must descend from (not necessarily direct parent of) the
	// specified mandatory parent string which is either a tag name or a tag
	// spec_name (e.g. tag.name = "!DOCTYPE" or tag.spec_name = "html doctype").
	MandatoryAncestor *string `protobuf:"bytes,15,opt,name=mandatory_ancestor,json=mandatoryAncestor" json:"mandatory_ancestor,omitempty"`
	// Use only for tags where mandatory_ancestor is set. If tag validation fails
	// due to the mandatory_ancestor, and this field is set, then the error
	// detail will suggest the tag specified here as an alternative to consider.
	MandatoryAncestorSuggestedAlternative *string `protobuf:"bytes,16,opt,name=mandatory_ancestor_suggested_alternative,json=mandatoryAncestorSuggestedAlternative" json:"mandatory_ancestor_suggested_alternative,omitempty"`
	// This tag may not descend from any tag with any of these tag names or tag
	// spec_names (e.g. tag.name = "!DOCTYPE" or tag.spec_name = "html doctype").
	DisallowedAncestor []string `protobuf:"bytes,13,rep,name=disallowed_ancestor,json=disallowedAncestor" json:"disallowed_ancestor,omitempty"`
	// If set, all of the tag's descendants must be tags from the named list.
	// A tag not in the named list will generate an error.
	DescendantTagList *string `protobuf:"bytes,29,opt,name=descendant_tag_list,json=descendantTagList" json:"descendant_tag_list,omitempty"`
	// If set, other tags - identified by their detail string - must be
	// present as well or a warning will be issued (will not invalidate doc).
	AlsoRequiresTagWarning []string `protobuf:"bytes,22,rep,name=also_requires_tag_warning,json=alsoRequiresTagWarning" json:"also_requires_tag_warning,omitempty"`
	// Expresses a generic condition which is satisfied if this tag is found. Used
	// in combination with the `requires` attribute on a different tag.
	Satisfies []string `protobuf:"bytes,23,rep,name=satisfies" json:"satisfies,omitempty"`
	// Expresses a generic condition which must be satisfied if this tag is found.
	// Used in combination with the `satisfies` attributes on a different tag.
	Requires []string `protobuf:"bytes,24,rep,name=requires" json:"requires,omitempty"`
	// The excludes field is a generic condition, which must not be satisfied if
	// this tag is found. Otherwise a TAG_EXCLUDED_BY_TAG error will be generated.
	// Used in combination with the `satisfies` attributes on a different tag.
	Excludes []string `protobuf:"bytes,32,rep,name=excludes" json:"excludes,omitempty"`
	// If set, generates a DEPRECATED_TAG error with severity WARNING.
	// The value of the deprecation field indicates what to use instead,
	// e.g. the name of a tag.
	Deprecation *string `protobuf:"bytes,17,opt,name=deprecation" json:"deprecation,omitempty"`
	// If provided, a URL which links to the AMP HTML spec for this deprecation.
	DeprecationUrl *string `protobuf:"bytes,18,opt,name=deprecation_url,json=deprecationUrl" json:"deprecation_url,omitempty"`
	// This TagSpec will only validate against attributes explicitly
	// listed within the TagSpec (attrs and attr_lists). No attributes
	// from $GLOBAL_ATTRS and $AMP_LAYOUT_ATTRS are valid unless explicitly
	// added as an attribute within the TagSpec. The field `amp_layout` is not
	// allowed to be set when `explicit_attrs_only` is true.
	ExplicitAttrsOnly *bool `protobuf:"varint,34,opt,name=explicit_attrs_only,json=explicitAttrsOnly,def=0" json:"explicit_attrs_only,omitempty"`
	// Attribute specifications related to this tag.
	Attrs []*AttrSpec `protobuf:"bytes,7,rep,name=attrs" json:"attrs,omitempty"`
	// Top level attr lists of shared tags, identified by unique key
	// (see attr_lists map in ValidatorRules).
	AttrLists []string `protobuf:"bytes,8,rep,name=attr_lists,json=attrLists" json:"attr_lists,omitempty"`
	// Note that these are evaluated after a particular TagSpec
	// has been evaluated. Unlike other checks in this TagSpec, we
	// no longer have the ability to fall back on a different TagSpec.
	Cdata *CdataSpec `protobuf:"bytes,12,opt,name=cdata" json:"cdata,omitempty"`
	// Specifies which tags can be the child tags, that is, immediately children
	// of this tag in the document.
	ChildTags *ChildTagSpec `protobuf:"bytes,19,opt,name=child_tags,json=childTags" json:"child_tags,omitempty"`
	// If set to true, this tag cannot have any siblings.
	SiblingsDisallowed *bool `protobuf:"varint,30,opt,name=siblings_disallowed,json=siblingsDisallowed,def=0" json:"siblings_disallowed,omitempty"`
	// If set to true, this tag must be the last child of its parent.
	MandatoryLastChild *bool `protobuf:"varint,31,opt,name=mandatory_last_child,json=mandatoryLastChild,def=0" json:"mandatory_last_child,omitempty"`
	// The reference_points defined by this TagSpec instance determine how
	// specific child tags are identified. Please see the comment for the
	// ReferencePoint message.
	ReferencePoints []*ReferencePoint `protobuf:"bytes,20,rep,name=reference_points,json=referencePoints" json:"reference_points,omitempty"`
	// If provided, a URL which linking to a section / sentence in the
	// AMP HTML spec. If a TagSpec contains a requires_extension field,
	// spec_url will be inherited from the named extension, unless overridden
	// by the setting it here.
	SpecUrl *string `protobuf:"bytes,10,opt,name=spec_url,json=specUrl" json:"spec_url,omitempty"`
	// If set, specifies which AMP Layouts are supported by this element.
	AmpLayout *AmpLayout `protobuf:"bytes,11,opt,name=amp_layout,json=ampLayout" json:"amp_layout,omitempty"`
	// If set, triggers related validation rules for descendants of this tag.
	MarkDescendants      *AncestorMarker `protobuf:"bytes,38,opt,name=mark_descendants,json=markDescendants" json:"mark_descendants,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *TagSpec) Reset()         { *m = TagSpec{} }
func (m *TagSpec) String() string { return proto.CompactTextString(m) }
func (*TagSpec) ProtoMessage()    {}
func (*TagSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{21}
}

func (m *TagSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TagSpec.Unmarshal(m, b)
}
func (m *TagSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TagSpec.Marshal(b, m, deterministic)
}
func (m *TagSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TagSpec.Merge(m, src)
}
func (m *TagSpec) XXX_Size() int {
	return xxx_messageInfo_TagSpec.Size(m)
}
func (m *TagSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_TagSpec.DiscardUnknown(m)
}

var xxx_messageInfo_TagSpec proto.InternalMessageInfo

const Default_TagSpec_NamedId TagSpec_NamedId = TagSpec_NOT_SET
const Default_TagSpec_ExplicitAttrsOnly bool = false
const Default_TagSpec_SiblingsDisallowed bool = false
const Default_TagSpec_MandatoryLastChild bool = false

func (m *TagSpec) GetHtmlFormat() []HtmlFormat_Code {
	if m != nil {
		return m.HtmlFormat
	}
	return nil
}

func (m *TagSpec) GetEnabledBy() []string {
	if m != nil {
		return m.EnabledBy
	}
	return nil
}

func (m *TagSpec) GetDisabledBy() []string {
	if m != nil {
		return m.DisabledBy
	}
	return nil
}

func (m *TagSpec) GetTagName() string {
	if m != nil && m.TagName != nil {
		return *m.TagName
	}
	return ""
}

func (m *TagSpec) GetSpecName() string {
	if m != nil && m.SpecName != nil {
		return *m.SpecName
	}
	return ""
}

func (m *TagSpec) GetDescriptiveName() string {
	if m != nil && m.DescriptiveName != nil {
		return *m.DescriptiveName
	}
	return ""
}

func (m *TagSpec) GetNamedId() TagSpec_NamedId {
	if m != nil && m.NamedId != nil {
		return *m.NamedId
	}
	return Default_TagSpec_NamedId
}

func (m *TagSpec) GetExtensionSpec() *ExtensionSpec {
	if m != nil {
		return m.ExtensionSpec
	}
	return nil
}

func (m *TagSpec) GetRequiresExtension() []string {
	if m != nil {
		return m.RequiresExtension
	}
	return nil
}

func (m *TagSpec) GetMandatory() bool {
	if m != nil && m.Mandatory != nil {
		return *m.Mandatory
	}
	return false
}

func (m *TagSpec) GetMandatoryAlternatives() string {
	if m != nil && m.MandatoryAlternatives != nil {
		return *m.MandatoryAlternatives
	}
	return ""
}

func (m *TagSpec) GetUnique() bool {
	if m != nil && m.Unique != nil {
		return *m.Unique
	}
	return false
}

func (m *TagSpec) GetUniqueWarning() bool {
	if m != nil && m.UniqueWarning != nil {
		return *m.UniqueWarning
	}
	return false
}

func (m *TagSpec) GetMandatoryParent() string {
	if m != nil && m.MandatoryParent != nil {
		return *m.MandatoryParent
	}
	return ""
}

func (m *TagSpec) GetMandatoryAncestor() string {
	if m != nil && m.MandatoryAncestor != nil {
		return *m.MandatoryAncestor
	}
	return ""
}

func (m *TagSpec) GetMandatoryAncestorSuggestedAlternative() string {
	if m != nil && m.MandatoryAncestorSuggestedAlternative != nil {
		return *m.MandatoryAncestorSuggestedAlternative
	}
	return ""
}

func (m *TagSpec) GetDisallowedAncestor() []string {
	if m != nil {
		return m.DisallowedAncestor
	}
	return nil
}

func (m *TagSpec) GetDescendantTagList() string {
	if m != nil && m.DescendantTagList != nil {
		return *m.DescendantTagList
	}
	return ""
}

func (m *TagSpec) GetAlsoRequiresTagWarning() []string {
	if m != nil {
		return m.AlsoRequiresTagWarning
	}
	return nil
}

func (m *TagSpec) GetSatisfies() []string {
	if m != nil {
		return m.Satisfies
	}
	return nil
}

func (m *TagSpec) GetRequires() []string {
	if m != nil {
		return m.Requires
	}
	return nil
}

func (m *TagSpec) GetExcludes() []string {
	if m != nil {
		return m.Excludes
	}
	return nil
}

func (m *TagSpec) GetDeprecation() string {
	if m != nil && m.Deprecation != nil {
		return *m.Deprecation
	}
	return ""
}

func (m *TagSpec) GetDeprecationUrl() string {
	if m != nil && m.DeprecationUrl != nil {
		return *m.DeprecationUrl
	}
	return ""
}

func (m *TagSpec) GetExplicitAttrsOnly() bool {
	if m != nil && m.ExplicitAttrsOnly != nil {
		return *m.ExplicitAttrsOnly
	}
	return Default_TagSpec_ExplicitAttrsOnly
}

func (m *TagSpec) GetAttrs() []*AttrSpec {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *TagSpec) GetAttrLists() []string {
	if m != nil {
		return m.AttrLists
	}
	return nil
}

func (m *TagSpec) GetCdata() *CdataSpec {
	if m != nil {
		return m.Cdata
	}
	return nil
}

func (m *TagSpec) GetChildTags() *ChildTagSpec {
	if m != nil {
		return m.ChildTags
	}
	return nil
}

func (m *TagSpec) GetSiblingsDisallowed() bool {
	if m != nil && m.SiblingsDisallowed != nil {
		return *m.SiblingsDisallowed
	}
	return Default_TagSpec_SiblingsDisallowed
}

func (m *TagSpec) GetMandatoryLastChild() bool {
	if m != nil && m.MandatoryLastChild != nil {
		return *m.MandatoryLastChild
	}
	return Default_TagSpec_MandatoryLastChild
}

func (m *TagSpec) GetReferencePoints() []*ReferencePoint {
	if m != nil {
		return m.ReferencePoints
	}
	return nil
}

func (m *TagSpec) GetSpecUrl() string {
	if m != nil && m.SpecUrl != nil {
		return *m.SpecUrl
	}
	return ""
}

func (m *TagSpec) GetAmpLayout() *AmpLayout {
	if m != nil {
		return m.AmpLayout
	}
	return nil
}

func (m *TagSpec) GetMarkDescendants() *AncestorMarker {
	if m != nil {
		return m.MarkDescendants
	}
	return nil
}

// Exactly one DocSpec will match each AMP document. This spec defines some
// default rules for the entire document scoped by it's HtmlFormat and any
// Type Identifiers.
// NEXT AVAILABLE TAG: 6
type DocSpec struct {
	// The html_format field tells the validator for which html formats
	// (ie: (<html ⚡> vs <html a4⚡>) this DocSpec is defined for.
	HtmlFormat []HtmlFormat_Code `protobuf:"varint,1,rep,name=html_format,json=htmlFormat,enum=amp.validator.HtmlFormat_Code" json:"html_format,omitempty"`
	// If a Type Identifier is in enabled_by then this DocSpec will be used
	// in validating parsed documents with that Type Identifier. If a Type
	// Identifier is in disabled_by then this DocSpec will not be used in
	// validating parsed documents with that Type Identifier. An DocSpec can
	// not have both enabled_by and disabled_by set.
	EnabledBy  []string `protobuf:"bytes,2,rep,name=enabled_by,json=enabledBy" json:"enabled_by,omitempty"`
	DisabledBy []string `protobuf:"bytes,3,rep,name=disabled_by,json=disabledBy" json:"disabled_by,omitempty"`
	// If set, the entire document's content cannot be greater than this length,
	// in bytes. A value of -2 (default) indicates that there is no limit
	// (unlimited).
	MaxBytes *int32 `protobuf:"varint,4,opt,name=max_bytes,json=maxBytes,def=-2" json:"max_bytes,omitempty"`
	// If provided, a URL linking to a section / sentence in the AMP HTML spec.
	MaxBytesSpecUrl      *string  `protobuf:"bytes,5,opt,name=max_bytes_spec_url,json=maxBytesSpecUrl" json:"max_bytes_spec_url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DocSpec) Reset()         { *m = DocSpec{} }
func (m *DocSpec) String() string { return proto.CompactTextString(m) }
func (*DocSpec) ProtoMessage()    {}
func (*DocSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{22}
}

func (m *DocSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DocSpec.Unmarshal(m, b)
}
func (m *DocSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DocSpec.Marshal(b, m, deterministic)
}
func (m *DocSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocSpec.Merge(m, src)
}
func (m *DocSpec) XXX_Size() int {
	return xxx_messageInfo_DocSpec.Size(m)
}
func (m *DocSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_DocSpec.DiscardUnknown(m)
}

var xxx_messageInfo_DocSpec proto.InternalMessageInfo

const Default_DocSpec_MaxBytes int32 = -2

func (m *DocSpec) GetHtmlFormat() []HtmlFormat_Code {
	if m != nil {
		return m.HtmlFormat
	}
	return nil
}

func (m *DocSpec) GetEnabledBy() []string {
	if m != nil {
		return m.EnabledBy
	}
	return nil
}

func (m *DocSpec) GetDisabledBy() []string {
	if m != nil {
		return m.DisabledBy
	}
	return nil
}

func (m *DocSpec) GetMaxBytes() int32 {
	if m != nil && m.MaxBytes != nil {
		return *m.MaxBytes
	}
	return Default_DocSpec_MaxBytes
}

func (m *DocSpec) GetMaxBytesSpecUrl() string {
	if m != nil && m.MaxBytesSpecUrl != nil {
		return *m.MaxBytesSpecUrl
	}
	return ""
}

// Exactly one DocCssSpec will match each AMP document. This spec defines the
// default css rules for style attributes and publisher style tags across the
// entire document. Rules for specific tags may be overridden by those tags.
// NEXT AVAILABLE TAG: 20
type DocCssSpec struct {
	// The html_format field tells the validator for which html formats
	// (ie: (<html ⚡> vs <html a4⚡>) this DocCssSpec is defined for.
	HtmlFormat []HtmlFormat_Code `protobuf:"varint,1,rep,name=html_format,json=htmlFormat,enum=amp.validator.HtmlFormat_Code" json:"html_format,omitempty"`
	// If a Type Identifier is in enabled_by then this DocCssSpec will be used
	// in validating parsed documents with that Type Identifier. If a Type
	// Identifier is in disabled_by then this DocCssSpec will not be used in
	// validating parsed documents;: with that Type Identifier. An DocCssSpec can
	// not have both enabled_by and disabled_by set.
	EnabledBy  []string `protobuf:"bytes,2,rep,name=enabled_by,json=enabledBy" json:"enabled_by,omitempty"`
	DisabledBy []string `protobuf:"bytes,3,rep,name=disabled_by,json=disabledBy" json:"disabled_by,omitempty"`
	// If provided, a URL linking to a section / sentence in the AMP HTML spec.
	SpecUrl *string `protobuf:"bytes,4,opt,name=spec_url,json=specUrl" json:"spec_url,omitempty"`
	// Due to a bug, we allowed unlimited doc-level and per-inline-style bytes
	// for CSS in non-AMP formats. To avoid breaking pages, some formats will
	// only emit a warning for exceeding `max_bytes` and
	// `max_bytes_per_inline_style`.
	MaxBytesIsWarning *bool `protobuf:"varint,18,opt,name=max_bytes_is_warning,json=maxBytesIsWarning,def=0" json:"max_bytes_is_warning,omitempty"`
	// If set, the combined style amp-custom cdata contents and all inline style
	// contents cannot be greater than this length, in bytes. A value of -2
	// (default) indicates that there is no limit (unlimited). A value of -1 will
	// always cause validation failure.
	MaxBytes *int32 `protobuf:"varint,5,opt,name=max_bytes,json=maxBytes,def=-2" json:"max_bytes,omitempty"`
	// If set, the inline style content (per use) cannot be greater than this
	// length, in bytes.
	MaxBytesPerInlineStyle *int32 `protobuf:"varint,6,opt,name=max_bytes_per_inline_style,json=maxBytesPerInlineStyle,def=-1" json:"max_bytes_per_inline_style,omitempty"`
	// If false, bytes inside URLs are not included in the byte calculation for
	// `max_bytes`. This is used for handling signed exchange transformations
	// which can potentially take the number of bytes over the 75,000 byte limit
	// due to rewriting URLs to point at an AMP Cache.
	UrlBytesIncluded *bool `protobuf:"varint,7,opt,name=url_bytes_included,json=urlBytesIncluded,def=1" json:"url_bytes_included,omitempty"`
	// If provided, a URL linking to a section / sentence in the AMP HTML spec.
	MaxBytesSpecUrl *string `protobuf:"bytes,8,opt,name=max_bytes_spec_url,json=maxBytesSpecUrl" json:"max_bytes_spec_url,omitempty"`
	// If true, all declarations are allowed in style tags and inline style
	// attributes, regardless of the contents of the `declaration` list.
	AllowAllDeclarationInStyle *bool `protobuf:"varint,10,opt,name=allow_all_declaration_in_style,json=allowAllDeclarationInStyle,def=0" json:"allow_all_declaration_in_style,omitempty"`
	// If true, all variants of declarations that are vendor prefixes are allowed.
	// for example, if `gradient` is an allowed declaration and this is true, then
	// `-webkit-gradient` is also an allowed declaration.
	ExpandVendorPrefixes *bool `protobuf:"varint,19,opt,name=expand_vendor_prefixes,json=expandVendorPrefixes" json:"expand_vendor_prefixes,omitempty"`
	// Any declaration listed here is allowed in custom style tags and style
	// attributes in any tag.
	Declaration []*CssDeclaration `protobuf:"bytes,11,rep,name=declaration" json:"declaration,omitempty"`
	// In addition to those listed in 'declaration', any declaration listed here
	// is allowed in style attributes for SVG elements.
	DeclarationSvg []*CssDeclaration `protobuf:"bytes,12,rep,name=declaration_svg,json=declarationSvg" json:"declaration_svg,omitempty"`
	// Top level lists of shared declarations, identified by unique key.
	DeclarationList []string `protobuf:"bytes,13,rep,name=declaration_list,json=declarationList" json:"declaration_list,omitempty"`
	// Top level lists of shared declarations, identified by unique key.
	DeclarationListSvg []string `protobuf:"bytes,14,rep,name=declaration_list_svg,json=declarationListSvg" json:"declaration_list_svg,omitempty"`
	// URLs found within CSS are checked against this spec.
	ImageUrlSpec *UrlSpec `protobuf:"bytes,15,opt,name=image_url_spec,json=imageUrlSpec" json:"image_url_spec,omitempty"`
	FontUrlSpec  *UrlSpec `protobuf:"bytes,16,opt,name=font_url_spec,json=fontUrlSpec" json:"font_url_spec,omitempty"`
	// If false, declarations tagged with `!important` are considered errors.
	// Most AMP stylesheets disallow `!important` to reserve this override
	// for AMP's own styles.
	AllowImportant       *bool    `protobuf:"varint,17,opt,name=allow_important,json=allowImportant,def=0" json:"allow_important,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DocCssSpec) Reset()         { *m = DocCssSpec{} }
func (m *DocCssSpec) String() string { return proto.CompactTextString(m) }
func (*DocCssSpec) ProtoMessage()    {}
func (*DocCssSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{23}
}

func (m *DocCssSpec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DocCssSpec.Unmarshal(m, b)
}
func (m *DocCssSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DocCssSpec.Marshal(b, m, deterministic)
}
func (m *DocCssSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocCssSpec.Merge(m, src)
}
func (m *DocCssSpec) XXX_Size() int {
	return xxx_messageInfo_DocCssSpec.Size(m)
}
func (m *DocCssSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_DocCssSpec.DiscardUnknown(m)
}

var xxx_messageInfo_DocCssSpec proto.InternalMessageInfo

const Default_DocCssSpec_MaxBytesIsWarning bool = false
const Default_DocCssSpec_MaxBytes int32 = -2
const Default_DocCssSpec_MaxBytesPerInlineStyle int32 = -1
const Default_DocCssSpec_UrlBytesIncluded bool = true
const Default_DocCssSpec_AllowAllDeclarationInStyle bool = false
const Default_DocCssSpec_AllowImportant bool = false

func (m *DocCssSpec) GetHtmlFormat() []HtmlFormat_Code {
	if m != nil {
		return m.HtmlFormat
	}
	return nil
}

func (m *DocCssSpec) GetEnabledBy() []string {
	if m != nil {
		return m.EnabledBy
	}
	return nil
}

func (m *DocCssSpec) GetDisabledBy() []string {
	if m != nil {
		return m.DisabledBy
	}
	return nil
}

func (m *DocCssSpec) GetSpecUrl() string {
	if m != nil && m.SpecUrl != nil {
		return *m.SpecUrl
	}
	return ""
}

func (m *DocCssSpec) GetMaxBytesIsWarning() bool {
	if m != nil && m.MaxBytesIsWarning != nil {
		return *m.MaxBytesIsWarning
	}
	return Default_DocCssSpec_MaxBytesIsWarning
}

func (m *DocCssSpec) GetMaxBytes() int32 {
	if m != nil && m.MaxBytes != nil {
		return *m.MaxBytes
	}
	return Default_DocCssSpec_MaxBytes
}

func (m *DocCssSpec) GetMaxBytesPerInlineStyle() int32 {
	if m != nil && m.MaxBytesPerInlineStyle != nil {
		return *m.MaxBytesPerInlineStyle
	}
	return Default_DocCssSpec_MaxBytesPerInlineStyle
}

func (m *DocCssSpec) GetUrlBytesIncluded() bool {
	if m != nil && m.UrlBytesIncluded != nil {
		return *m.UrlBytesIncluded
	}
	return Default_DocCssSpec_UrlBytesIncluded
}

func (m *DocCssSpec) GetMaxBytesSpecUrl() string {
	if m != nil && m.MaxBytesSpecUrl != nil {
		return *m.MaxBytesSpecUrl
	}
	return ""
}

func (m *DocCssSpec) GetAllowAllDeclarationInStyle() bool {
	if m != nil && m.AllowAllDeclarationInStyle != nil {
		return *m.AllowAllDeclarationInStyle
	}
	return Default_DocCssSpec_AllowAllDeclarationInStyle
}

func (m *DocCssSpec) GetExpandVendorPrefixes() bool {
	if m != nil && m.ExpandVendorPrefixes != nil {
		return *m.ExpandVendorPrefixes
	}
	return false
}

func (m *DocCssSpec) GetDeclaration() []*CssDeclaration {
	if m != nil {
		return m.Declaration
	}
	return nil
}

func (m *DocCssSpec) GetDeclarationSvg() []*CssDeclaration {
	if m != nil {
		return m.DeclarationSvg
	}
	return nil
}

func (m *DocCssSpec) GetDeclarationList() []string {
	if m != nil {
		return m.DeclarationList
	}
	return nil
}

func (m *DocCssSpec) GetDeclarationListSvg() []string {
	if m != nil {
		return m.DeclarationListSvg
	}
	return nil
}

func (m *DocCssSpec) GetImageUrlSpec() *UrlSpec {
	if m != nil {
		return m.ImageUrlSpec
	}
	return nil
}

func (m *DocCssSpec) GetFontUrlSpec() *UrlSpec {
	if m != nil {
		return m.FontUrlSpec
	}
	return nil
}

func (m *DocCssSpec) GetAllowImportant() bool {
	if m != nil && m.AllowImportant != nil {
		return *m.AllowImportant
	}
	return Default_DocCssSpec_AllowImportant
}

// Top level message - start reading here.
// The validator knows about a set of tag specifications.
// NEXT AVAILABLE TAG: 22
type ValidatorRules struct {
	Tags      []*TagSpec  `protobuf:"bytes,1,rep,name=tags" json:"tags,omitempty"`
	AttrLists []*AttrList `protobuf:"bytes,7,rep,name=attr_lists,json=attrLists" json:"attr_lists,omitempty"`
	// The min file revision for validator.cc which can digest this file.
	MinValidatorRevisionRequired *int32 `protobuf:"varint,4,opt,name=min_validator_revision_required,json=minValidatorRevisionRequired" json:"min_validator_revision_required,omitempty"`
	// See comment in validator.protoascii.
	SpecFileRevision *int32 `protobuf:"varint,6,opt,name=spec_file_revision,json=specFileRevision,def=-1" json:"spec_file_revision,omitempty"`
	// Spec URL for information about mustache templates.
	TemplateSpecUrl *string `protobuf:"bytes,8,opt,name=template_spec_url,json=templateSpecUrl" json:"template_spec_url,omitempty"`
	// Spec URL for information about styles and amp-custom stylesheet
	StylesSpecUrl *string `protobuf:"bytes,15,opt,name=styles_spec_url,json=stylesSpecUrl" json:"styles_spec_url,omitempty"`
	// Spec URL for information about script tags.
	ScriptSpecUrl     *string              `protobuf:"bytes,17,opt,name=script_spec_url,json=scriptSpecUrl" json:"script_spec_url,omitempty"`
	ErrorFormats      []*ErrorFormat       `protobuf:"bytes,9,rep,name=error_formats,json=errorFormats" json:"error_formats,omitempty"`
	ErrorSpecificity  []*ErrorSpecificity  `protobuf:"bytes,13,rep,name=error_specificity,json=errorSpecificity" json:"error_specificity,omitempty"`
	DescendantTagList []*DescendantTagList `protobuf:"bytes,16,rep,name=descendant_tag_list,json=descendantTagList" json:"descendant_tag_list,omitempty"`
	// The DocSpec rules are scoped by the document's HtmlFormat and Type
	// Identifiers and defined within each DocSpec.
	Doc                  []*DocSpec         `protobuf:"bytes,21,rep,name=doc" json:"doc,omitempty"`
	Css                  []*DocCssSpec      `protobuf:"bytes,19,rep,name=css" json:"css,omitempty"`
	DeclarationList      []*DeclarationList `protobuf:"bytes,20,rep,name=declaration_list,json=declarationList" json:"declaration_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *ValidatorRules) Reset()         { *m = ValidatorRules{} }
func (m *ValidatorRules) String() string { return proto.CompactTextString(m) }
func (*ValidatorRules) ProtoMessage()    {}
func (*ValidatorRules) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{24}
}

func (m *ValidatorRules) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ValidatorRules.Unmarshal(m, b)
}
func (m *ValidatorRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ValidatorRules.Marshal(b, m, deterministic)
}
func (m *ValidatorRules) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorRules.Merge(m, src)
}
func (m *ValidatorRules) XXX_Size() int {
	return xxx_messageInfo_ValidatorRules.Size(m)
}
func (m *ValidatorRules) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorRules.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorRules proto.InternalMessageInfo

const Default_ValidatorRules_SpecFileRevision int32 = -1

func (m *ValidatorRules) GetTags() []*TagSpec {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *ValidatorRules) GetAttrLists() []*AttrList {
	if m != nil {
		return m.AttrLists
	}
	return nil
}

func (m *ValidatorRules) GetMinValidatorRevisionRequired() int32 {
	if m != nil && m.MinValidatorRevisionRequired != nil {
		return *m.MinValidatorRevisionRequired
	}
	return 0
}

func (m *ValidatorRules) GetSpecFileRevision() int32 {
	if m != nil && m.SpecFileRevision != nil {
		return *m.SpecFileRevision
	}
	return Default_ValidatorRules_SpecFileRevision
}

func (m *ValidatorRules) GetTemplateSpecUrl() string {
	if m != nil && m.TemplateSpecUrl != nil {
		return *m.TemplateSpecUrl
	}
	return ""
}

func (m *ValidatorRules) GetStylesSpecUrl() string {
	if m != nil && m.StylesSpecUrl != nil {
		return *m.StylesSpecUrl
	}
	return ""
}

func (m *ValidatorRules) GetScriptSpecUrl() string {
	if m != nil && m.ScriptSpecUrl != nil {
		return *m.ScriptSpecUrl
	}
	return ""
}

func (m *ValidatorRules) GetErrorFormats() []*ErrorFormat {
	if m != nil {
		return m.ErrorFormats
	}
	return nil
}

func (m *ValidatorRules) GetErrorSpecificity() []*ErrorSpecificity {
	if m != nil {
		return m.ErrorSpecificity
	}
	return nil
}

func (m *ValidatorRules) GetDescendantTagList() []*DescendantTagList {
	if m != nil {
		return m.DescendantTagList
	}
	return nil
}

func (m *ValidatorRules) GetDoc() []*DocSpec {
	if m != nil {
		return m.Doc
	}
	return nil
}

func (m *ValidatorRules) GetCss() []*DocCssSpec {
	if m != nil {
		return m.Css
	}
	return nil
}

func (m *ValidatorRules) GetDeclarationList() []*DeclarationList {
	if m != nil {
		return m.DeclarationList
	}
	return nil
}

// This feature was removed in October 2019, however there are still
// some callers that expect an ErrorCategory to be set. Do not rely
// on this in new code.
// TODO(#25188): Remove ErrorCategory completely.
type ErrorCategory struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ErrorCategory) Reset()         { *m = ErrorCategory{} }
func (m *ErrorCategory) String() string { return proto.CompactTextString(m) }
func (*ErrorCategory) ProtoMessage()    {}
func (*ErrorCategory) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{25}
}

func (m *ErrorCategory) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ErrorCategory.Unmarshal(m, b)
}
func (m *ErrorCategory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ErrorCategory.Marshal(b, m, deterministic)
}
func (m *ErrorCategory) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ErrorCategory.Merge(m, src)
}
func (m *ErrorCategory) XXX_Size() int {
	return xxx_messageInfo_ErrorCategory.Size(m)
}
func (m *ErrorCategory) XXX_DiscardUnknown() {
	xxx_messageInfo_ErrorCategory.DiscardUnknown(m)
}

var xxx_messageInfo_ErrorCategory proto.InternalMessageInfo

// We record validation errors in a structured form, so that they can be
// worked with in code - e.g., to provide translated messages.
// In the Javascript implementation (validator.js), you may find
// the amp.validator.renderErrorMessage function which will make a
// human-readable string from the structured form. It should be easy to port
// this to other languages as needed; for instance Google has implementations
// in C++, Java, and for templates used in some frontends.
// NEXT AVAILABLE TAG: 10
type ValidationError struct {
	Severity *ValidationError_Severity `protobuf:"varint,6,opt,name=severity,enum=amp.validator.ValidationError_Severity,def=1" json:"severity,omitempty"`
	Code     *ValidationError_Code     `protobuf:"varint,1,opt,name=code,enum=amp.validator.ValidationError_Code" json:"code,omitempty"`
	Line     *int32                    `protobuf:"varint,2,opt,name=line,def=1" json:"line,omitempty"`
	Col      *int32                    `protobuf:"varint,3,opt,name=col" json:"col,omitempty"`
	SpecUrl  *string                   `protobuf:"bytes,5,opt,name=spec_url,json=specUrl" json:"spec_url,omitempty"`
	Params   []string                  `protobuf:"bytes,7,rep,name=params" json:"params,omitempty"`
	// This field is deprecated. Do not use.
	Category *ErrorCategory_Code `protobuf:"varint,8,opt,name=category,enum=amp.validator.ErrorCategory_Code" json:"category,omitempty"`
	// Used only in JavaScript, if an error is emitted for a specific HTML tag and
	// if that HTML tag has an attribute named data-amp-report-test, this string
	// will be set and contain the value found for that attribute. This is used
	// in tests to match specific errors to specific tags in the test cases. It
	// is not a rendered value.
	DataAmpReportTestValue *string  `protobuf:"bytes,9,opt,name=data_amp_report_test_value,json=dataAmpReportTestValue" json:"data_amp_report_test_value,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *ValidationError) Reset()         { *m = ValidationError{} }
func (m *ValidationError) String() string { return proto.CompactTextString(m) }
func (*ValidationError) ProtoMessage()    {}
func (*ValidationError) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{26}
}

func (m *ValidationError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ValidationError.Unmarshal(m, b)
}
func (m *ValidationError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ValidationError.Marshal(b, m, deterministic)
}
func (m *ValidationError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidationError.Merge(m, src)
}
func (m *ValidationError) XXX_Size() int {
	return xxx_messageInfo_ValidationError.Size(m)
}
func (m *ValidationError) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidationError.DiscardUnknown(m)
}

var xxx_messageInfo_ValidationError proto.InternalMessageInfo

const Default_ValidationError_Severity ValidationError_Severity = ValidationError_ERROR
const Default_ValidationError_Line int32 = 1

func (m *ValidationError) GetSeverity() ValidationError_Severity {
	if m != nil && m.Severity != nil {
		return *m.Severity
	}
	return Default_ValidationError_Severity
}

func (m *ValidationError) GetCode() ValidationError_Code {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return ValidationError_UNKNOWN_CODE
}

func (m *ValidationError) GetLine() int32 {
	if m != nil && m.Line != nil {
		return *m.Line
	}
	return Default_ValidationError_Line
}

func (m *ValidationError) GetCol() int32 {
	if m != nil && m.Col != nil {
		return *m.Col
	}
	return 0
}

func (m *ValidationError) GetSpecUrl() string {
	if m != nil && m.SpecUrl != nil {
		return *m.SpecUrl
	}
	return ""
}

func (m *ValidationError) GetParams() []string {
	if m != nil {
		return m.Params
	}
	return nil
}

func (m *ValidationError) GetCategory() ErrorCategory_Code {
	if m != nil && m.Category != nil {
		return *m.Category
	}
	return ErrorCategory_UNKNOWN
}

func (m *ValidationError) GetDataAmpReportTestValue() string {
	if m != nil && m.DataAmpReportTestValue != nil {
		return *m.DataAmpReportTestValue
	}
	return ""
}

// Used in the verbose validator to select between multiple generated error
// types for a failing error. A higher number means that the error is more
// specific, ie: more helpful, preferred.
// NEXT AVAILABLE TAG: 3
type ErrorSpecificity struct {
	Code                 *ValidationError_Code `protobuf:"varint,1,opt,name=code,enum=amp.validator.ValidationError_Code" json:"code,omitempty"`
	Specificity          *int32                `protobuf:"varint,2,opt,name=specificity" json:"specificity,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ErrorSpecificity) Reset()         { *m = ErrorSpecificity{} }
func (m *ErrorSpecificity) String() string { return proto.CompactTextString(m) }
func (*ErrorSpecificity) ProtoMessage()    {}
func (*ErrorSpecificity) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{27}
}

func (m *ErrorSpecificity) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ErrorSpecificity.Unmarshal(m, b)
}
func (m *ErrorSpecificity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ErrorSpecificity.Marshal(b, m, deterministic)
}
func (m *ErrorSpecificity) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ErrorSpecificity.Merge(m, src)
}
func (m *ErrorSpecificity) XXX_Size() int {
	return xxx_messageInfo_ErrorSpecificity.Size(m)
}
func (m *ErrorSpecificity) XXX_DiscardUnknown() {
	xxx_messageInfo_ErrorSpecificity.DiscardUnknown(m)
}

var xxx_messageInfo_ErrorSpecificity proto.InternalMessageInfo

func (m *ErrorSpecificity) GetCode() ValidationError_Code {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return ValidationError_UNKNOWN_CODE
}

func (m *ErrorSpecificity) GetSpecificity() int32 {
	if m != nil && m.Specificity != nil {
		return *m.Specificity
	}
	return 0
}

// NEXT AVAILABLE TAG: 3
type ErrorFormat struct {
	Code                 *ValidationError_Code `protobuf:"varint,1,opt,name=code,enum=amp.validator.ValidationError_Code" json:"code,omitempty"`
	Format               *string               `protobuf:"bytes,2,opt,name=format" json:"format,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ErrorFormat) Reset()         { *m = ErrorFormat{} }
func (m *ErrorFormat) String() string { return proto.CompactTextString(m) }
func (*ErrorFormat) ProtoMessage()    {}
func (*ErrorFormat) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{28}
}

func (m *ErrorFormat) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ErrorFormat.Unmarshal(m, b)
}
func (m *ErrorFormat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ErrorFormat.Marshal(b, m, deterministic)
}
func (m *ErrorFormat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ErrorFormat.Merge(m, src)
}
func (m *ErrorFormat) XXX_Size() int {
	return xxx_messageInfo_ErrorFormat.Size(m)
}
func (m *ErrorFormat) XXX_DiscardUnknown() {
	xxx_messageInfo_ErrorFormat.DiscardUnknown(m)
}

var xxx_messageInfo_ErrorFormat proto.InternalMessageInfo

func (m *ErrorFormat) GetCode() ValidationError_Code {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return ValidationError_UNKNOWN_CODE
}

func (m *ErrorFormat) GetFormat() string {
	if m != nil && m.Format != nil {
		return *m.Format
	}
	return ""
}

// A value to be added to a particular ValueSet, as found when scanning the
// document (i.e. AttrSpec.add_value_to_set).
// NEXT AVAILABLE TAG: 3
type ValueSetProvision struct {
	// The collection to add the attribute value to.
	Set *AttrSpec_ValueSet `protobuf:"varint,1,opt,name=set,enum=amp.validator.AttrSpec_ValueSet" json:"set,omitempty"`
	// The value of the attribute itself.
	Value                *string  `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ValueSetProvision) Reset()         { *m = ValueSetProvision{} }
func (m *ValueSetProvision) String() string { return proto.CompactTextString(m) }
func (*ValueSetProvision) ProtoMessage()    {}
func (*ValueSetProvision) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{29}
}

func (m *ValueSetProvision) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ValueSetProvision.Unmarshal(m, b)
}
func (m *ValueSetProvision) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ValueSetProvision.Marshal(b, m, deterministic)
}
func (m *ValueSetProvision) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValueSetProvision.Merge(m, src)
}
func (m *ValueSetProvision) XXX_Size() int {
	return xxx_messageInfo_ValueSetProvision.Size(m)
}
func (m *ValueSetProvision) XXX_DiscardUnknown() {
	xxx_messageInfo_ValueSetProvision.DiscardUnknown(m)
}

var xxx_messageInfo_ValueSetProvision proto.InternalMessageInfo

func (m *ValueSetProvision) GetSet() AttrSpec_ValueSet {
	if m != nil && m.Set != nil {
		return *m.Set
	}
	return AttrSpec_UNKNOWN_VALUESET
}

func (m *ValueSetProvision) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

// A requirement that a particular value appears in a particular ValueSet (i.e.
// AttrSpec.value_oneof_set). All the provisions and requirements are collected
// until the document has been fully scanned, and then compared to ensure that
// all requirements are met. This allows provisions to appear after (or even
// alongside) requirements.
// NEXT AVAILABLE TAG: 3
type ValueSetRequirement struct {
	// The provision that is required.
	Provision *ValueSetProvision `protobuf:"bytes,1,opt,name=provision" json:"provision,omitempty"`
	// The error that will appear if the requirement is not met. This includes the
	// line/col of the attribute that makes the requirement.
	ErrorIfUnsatisfied   *ValidationError `protobuf:"bytes,2,opt,name=error_if_unsatisfied,json=errorIfUnsatisfied" json:"error_if_unsatisfied,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ValueSetRequirement) Reset()         { *m = ValueSetRequirement{} }
func (m *ValueSetRequirement) String() string { return proto.CompactTextString(m) }
func (*ValueSetRequirement) ProtoMessage()    {}
func (*ValueSetRequirement) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{30}
}

func (m *ValueSetRequirement) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ValueSetRequirement.Unmarshal(m, b)
}
func (m *ValueSetRequirement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ValueSetRequirement.Marshal(b, m, deterministic)
}
func (m *ValueSetRequirement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValueSetRequirement.Merge(m, src)
}
func (m *ValueSetRequirement) XXX_Size() int {
	return xxx_messageInfo_ValueSetRequirement.Size(m)
}
func (m *ValueSetRequirement) XXX_DiscardUnknown() {
	xxx_messageInfo_ValueSetRequirement.DiscardUnknown(m)
}

var xxx_messageInfo_ValueSetRequirement proto.InternalMessageInfo

func (m *ValueSetRequirement) GetProvision() *ValueSetProvision {
	if m != nil {
		return m.Provision
	}
	return nil
}

func (m *ValueSetRequirement) GetErrorIfUnsatisfied() *ValidationError {
	if m != nil {
		return m.ErrorIfUnsatisfied
	}
	return nil
}

// The validation result provided by Validator instances (see Validator::Result
// in validator.h). To render such a proto see RenderValidationResult.
// NEXT AVAILABLE TAG: 9
type ValidationResult struct {
	Status *ValidationResult_Status `protobuf:"varint,2,opt,name=status,enum=amp.validator.ValidationResult_Status" json:"status,omitempty"`
	Errors []*ValidationError       `protobuf:"bytes,1,rep,name=errors" json:"errors,omitempty"`
	// The following field is deprecated and can return any value. Do not depend
	// on this.
	ValidatorRevision *int32 `protobuf:"varint,3,opt,name=validator_revision,json=validatorRevision,def=-1" json:"validator_revision,omitempty"`
	SpecFileRevision  *int32 `protobuf:"varint,4,opt,name=spec_file_revision,json=specFileRevision,def=-1" json:"spec_file_revision,omitempty"`
	// If the AMP document is a transformed AMP document, then this is the
	// version of the transformers that were used to transform it. If the document
	// is not transformed, then the transformer_version's value will be 0.
	// Note: the AMP Pacakager's transformer library specifies the version as
	// int64. However, JavaScript does not natively support int64 so int32 is
	// used instead.
	// https://github.com/ampproject/amppackager/blob/master/transformer/transformers/context.go
	TransformerVersion *int32 `protobuf:"varint,6,opt,name=transformer_version,json=transformerVersion,def=0" json:"transformer_version,omitempty"`
	// The type idenfitier of the parsed document, e.g. AMP, AMP4ADS or some other
	// type that has yet to be defined. These are declared on the HTML tag and
	// parsed by the Validator Engine.
	TypeIdentifier []string `protobuf:"bytes,5,rep,name=type_identifier,json=typeIdentifier" json:"type_identifier,omitempty"`
	// The set of provisions from all matching AttrSpecs in this TagSpec match.
	// If the TagSpec is selected, these will be added to the final set of
	// provisions.
	ValueSetProvisions []*ValueSetProvision `protobuf:"bytes,7,rep,name=value_set_provisions,json=valueSetProvisions" json:"value_set_provisions,omitempty"`
	// The set of requirements from all matching AttrSpecs in this TagSpec match.
	// If the TagSpec is selected, these will be added to the final set of
	// requirements.
	ValueSetRequirements []*ValueSetRequirement `protobuf:"bytes,8,rep,name=value_set_requirements,json=valueSetRequirements" json:"value_set_requirements,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *ValidationResult) Reset()         { *m = ValidationResult{} }
func (m *ValidationResult) String() string { return proto.CompactTextString(m) }
func (*ValidationResult) ProtoMessage()    {}
func (*ValidationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_bf1c6ec7c0d80dd5, []int{31}
}

func (m *ValidationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ValidationResult.Unmarshal(m, b)
}
func (m *ValidationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ValidationResult.Marshal(b, m, deterministic)
}
func (m *ValidationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidationResult.Merge(m, src)
}
func (m *ValidationResult) XXX_Size() int {
	return xxx_messageInfo_ValidationResult.Size(m)
}
func (m *ValidationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidationResult.DiscardUnknown(m)
}

var xxx_messageInfo_ValidationResult proto.InternalMessageInfo

const Default_ValidationResult_ValidatorRevision int32 = -1
const Default_ValidationResult_SpecFileRevision int32 = -1
const Default_ValidationResult_TransformerVersion int32 = 0

func (m *ValidationResult) GetStatus() ValidationResult_Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return ValidationResult_UNKNOWN
}

func (m *ValidationResult) GetErrors() []*ValidationError {
	if m != nil {
		return m.Errors
	}
	return nil
}

func (m *ValidationResult) GetValidatorRevision() int32 {
	if m != nil && m.ValidatorRevision != nil {
		return *m.ValidatorRevision
	}
	return Default_ValidationResult_ValidatorRevision
}

func (m *ValidationResult) GetSpecFileRevision() int32 {
	if m != nil && m.SpecFileRevision != nil {
		return *m.SpecFileRevision
	}
	return Default_ValidationResult_SpecFileRevision
}

func (m *ValidationResult) GetTransformerVersion() int32 {
	if m != nil && m.TransformerVersion != nil {
		return *m.TransformerVersion
	}
	return Default_ValidationResult_TransformerVersion
}

func (m *ValidationResult) GetTypeIdentifier() []string {
	if m != nil {
		return m.TypeIdentifier
	}
	return nil
}

func (m *ValidationResult) GetValueSetProvisions() []*ValueSetProvision {
	if m != nil {
		return m.ValueSetProvisions
	}
	return nil
}

func (m *ValidationResult) GetValueSetRequirements() []*ValueSetRequirement {
	if m != nil {
		return m.ValueSetRequirements
	}
	return nil
}

func init() {
	proto.RegisterEnum("amp.validator.AttrSpec_ValueSet", AttrSpec_ValueSet_name, AttrSpec_ValueSet_value)
	proto.RegisterEnum("amp.validator.AttrSpec_DispatchKeyType", AttrSpec_DispatchKeyType_name, AttrSpec_DispatchKeyType_value)
	proto.RegisterEnum("amp.validator.AmpLayout_Layout", AmpLayout_Layout_name, AmpLayout_Layout_value)
	proto.RegisterEnum("amp.validator.AncestorMarker_Marker", AncestorMarker_Marker_name, AncestorMarker_Marker_value)
	proto.RegisterEnum("amp.validator.ExtensionSpec_ExtensionType", ExtensionSpec_ExtensionType_name, ExtensionSpec_ExtensionType_value)
	proto.RegisterEnum("amp.validator.ExtensionSpec_ExtensionUsageRequirement", ExtensionSpec_ExtensionUsageRequirement_name, ExtensionSpec_ExtensionUsageRequirement_value)
	proto.RegisterEnum("amp.validator.HtmlFormat_Code", HtmlFormat_Code_name, HtmlFormat_Code_value)
	proto.RegisterEnum("amp.validator.TagSpec_NamedId", TagSpec_NamedId_name, TagSpec_NamedId_value)
	proto.RegisterEnum("amp.validator.ErrorCategory_Code", ErrorCategory_Code_name, ErrorCategory_Code_value)
	proto.RegisterEnum("amp.validator.ValidationError_Severity", ValidationError_Severity_name, ValidationError_Severity_value)
	proto.RegisterEnum("amp.validator.ValidationError_Code", ValidationError_Code_name, ValidationError_Code_value)
	proto.RegisterEnum("amp.validator.ValidationResult_Status", ValidationResult_Status_name, ValidationResult_Status_value)
	proto.RegisterType((*AttrTriggerSpec)(nil), "amp.validator.AttrTriggerSpec")
	proto.RegisterType((*PropertySpec)(nil), "amp.validator.PropertySpec")
	proto.RegisterType((*PropertySpecList)(nil), "amp.validator.PropertySpecList")
	proto.RegisterType((*UrlSpec)(nil), "amp.validator.UrlSpec")
	proto.RegisterType((*CssDeclaration)(nil), "amp.validator.CssDeclaration")
	proto.RegisterType((*AttrSpec)(nil), "amp.validator.AttrSpec")
	proto.RegisterType((*AttrList)(nil), "amp.validator.AttrList")
	proto.RegisterType((*DescendantTagList)(nil), "amp.validator.DescendantTagList")
	proto.RegisterType((*DeclarationList)(nil), "amp.validator.DeclarationList")
	proto.RegisterType((*DisallowedCDataRegex)(nil), "amp.validator.DisallowedCDataRegex")
	proto.RegisterType((*MediaQuerySpec)(nil), "amp.validator.MediaQuerySpec")
	proto.RegisterType((*SelectorSpec)(nil), "amp.validator.SelectorSpec")
	proto.RegisterType((*AtRuleSpec)(nil), "amp.validator.AtRuleSpec")
	proto.RegisterType((*CssSpec)(nil), "amp.validator.CssSpec")
	proto.RegisterType((*CdataSpec)(nil), "amp.validator.CdataSpec")
	proto.RegisterType((*AmpLayout)(nil), "amp.validator.AmpLayout")
	proto.RegisterType((*AncestorMarker)(nil), "amp.validator.AncestorMarker")
	proto.RegisterType((*ChildTagSpec)(nil), "amp.validator.ChildTagSpec")
	proto.RegisterType((*ReferencePoint)(nil), "amp.validator.ReferencePoint")
	proto.RegisterType((*ExtensionSpec)(nil), "amp.validator.ExtensionSpec")
	proto.RegisterType((*HtmlFormat)(nil), "amp.validator.HtmlFormat")
	proto.RegisterType((*TagSpec)(nil), "amp.validator.TagSpec")
	proto.RegisterType((*DocSpec)(nil), "amp.validator.DocSpec")
	proto.RegisterType((*DocCssSpec)(nil), "amp.validator.DocCssSpec")
	proto.RegisterType((*ValidatorRules)(nil), "amp.validator.ValidatorRules")
	proto.RegisterType((*ErrorCategory)(nil), "amp.validator.ErrorCategory")
	proto.RegisterType((*ValidationError)(nil), "amp.validator.ValidationError")
	proto.RegisterType((*ErrorSpecificity)(nil), "amp.validator.ErrorSpecificity")
	proto.RegisterType((*ErrorFormat)(nil), "amp.validator.ErrorFormat")
	proto.RegisterType((*ValueSetProvision)(nil), "amp.validator.ValueSetProvision")
	proto.RegisterType((*ValueSetRequirement)(nil), "amp.validator.ValueSetRequirement")
	proto.RegisterType((*ValidationResult)(nil), "amp.validator.ValidationResult")
}

func init() { proto.RegisterFile("validator.proto", fileDescriptor_bf1c6ec7c0d80dd5) }

var fileDescriptor_bf1c6ec7c0d80dd5 = []byte{
	// 5255 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5b, 0x4f, 0x77, 0x1b, 0x47,
	0x72, 0x37, 0xff, 0x83, 0x45, 0x12, 0x6c, 0x36, 0x29, 0x1a, 0xfa, 0x63, 0x89, 0x1e, 0xcb, 0x96,
	0x6c, 0xad, 0x69, 0x5b, 0xeb, 0xb5, 0xbd, 0x5a, 0xaf, 0xbd, 0x43, 0xa0, 0x21, 0x8e, 0x35, 0x98,
	0x81, 0x7a, 0x06, 0x94, 0xb8, 0xc9, 0x6e, 0x67, 0x04, 0x0c, 0xa9, 0x59, 0xe3, 0x9f, 0x67, 0x06,
	0xb4, 0x98, 0x4b, 0x3e, 0x40, 0x8e, 0xb9, 0xe5, 0x9e, 0x97, 0x0f, 0x90, 0x1c, 0xf2, 0x5e, 0xbe,
	0x48, 0x72, 0xcc, 0x3d, 0x1f, 0x21, 0x2f, 0x2f, 0xaf, 0xba, 0xe7, 0x1f, 0x06, 0xa0, 0xa4, 0x6c,
	0x2e, 0x39, 0x89, 0x53, 0xf5, 0xab, 0xee, 0xea, 0xea, 0xea, 0xaa, 0xea, 0x6a, 0x08, 0xb6, 0x2f,
	0xbc, 0x7e, 0xd0, 0xf3, 0xe2, 0x51, 0x78, 0x38, 0x0e, 0x47, 0xf1, 0x88, 0x6e, 0x79, 0x83, 0xf1,
	0x61, 0x46, 0xd4, 0x7c, 0xd8, 0xd6, 0xe3, 0x38, 0x74, 0xc3, 0xe0, 0xfc, 0xdc, 0x0f, 0x9d, 0xb1,
	0xdf, 0xa5, 0x77, 0xa1, 0x1a, 0x9c, 0x89, 0x0b, 0xaf, 0x3f, 0xf1, 0x45, 0xe8, 0x9f, 0xfb, 0xaf,
	0x6a, 0x0b, 0x07, 0x0b, 0xf7, 0xd7, 0xf9, 0x66, 0x70, 0x76, 0x82, 0x44, 0x8e, 0x34, 0xfa, 0x0b,
	0xa0, 0x5e, 0x3f, 0x1a, 0x89, 0xd0, 0xff, 0x69, 0x12, 0x84, 0x7e, 0x24, 0xbc, 0x38, 0x0e, 0x6b,
	0x8b, 0x07, 0x4b, 0xf7, 0xd7, 0x39, 0x41, 0x0e, 0x4f, 0x18, 0x38, 0xbc, 0x76, 0x09, 0x9b, 0xed,
	0x70, 0x34, 0xf6, 0xc3, 0xf8, 0x52, 0xce, 0x41, 0x61, 0x79, 0xe8, 0x0d, 0xfc, 0x64, 0x64, 0xf9,
	0x37, 0xbd, 0x05, 0xeb, 0x03, 0x6f, 0x28, 0xd5, 0xba, 0xac, 0x2d, 0x1e, 0x2c, 0xdc, 0xaf, 0xf0,
	0x9c, 0x40, 0xf7, 0x60, 0x45, 0xaa, 0x54, 0x5b, 0x92, 0x22, 0xea, 0x83, 0xbe, 0x0f, 0x9b, 0x4a,
	0xd1, 0xde, 0x68, 0xf2, 0xa2, 0xef, 0xd7, 0x96, 0x0f, 0x16, 0xee, 0x2f, 0xf0, 0x0d, 0x49, 0x6b,
	0x48, 0x92, 0x66, 0x03, 0x29, 0x4e, 0x6d, 0x06, 0x51, 0x4c, 0x7f, 0x03, 0x30, 0x56, 0xb4, 0xc0,
	0x8f, 0x6a, 0x0b, 0x07, 0x4b, 0xf7, 0x37, 0x1e, 0xde, 0x3c, 0x9c, 0xb2, 0xcc, 0x61, 0x51, 0x88,
	0x17, 0xe0, 0xda, 0x5f, 0xc3, 0x5a, 0x27, 0xec, 0xcb, 0x65, 0xdc, 0x80, 0x8a, 0xb4, 0x6a, 0x77,
	0xd4, 0x97, 0xa3, 0xac, 0xf3, 0xec, 0x9b, 0x3e, 0x80, 0xaa, 0xd7, 0xef, 0x8f, 0x7e, 0x16, 0xa1,
	0xdf, 0xf7, 0xe2, 0xe0, 0xc2, 0x57, 0x6b, 0x7a, 0xb4, 0x1c, 0x87, 0x13, 0x9f, 0x6f, 0x49, 0x1e,
	0x4f, 0x58, 0xf4, 0x23, 0xd8, 0x50, 0x60, 0x7f, 0x30, 0x8e, 0x2f, 0xe5, 0x1a, 0x2b, 0x8f, 0x56,
	0xce, 0xbc, 0x7e, 0xe4, 0x73, 0x90, 0x1c, 0x86, 0x0c, 0xed, 0x27, 0xa8, 0xd6, 0xa3, 0xa8, 0xe1,
	0x77, 0xfb, 0x5e, 0xe8, 0xc5, 0xc1, 0x68, 0x38, 0xd7, 0x92, 0x77, 0x40, 0x59, 0x40, 0x74, 0xbd,
	0xc8, 0x0f, 0x92, 0x4d, 0x01, 0x49, 0xaa, 0x23, 0x85, 0x7e, 0x02, 0x3b, 0x85, 0xfd, 0x4d, 0x60,
	0xca, 0xb0, 0xdb, 0x17, 0xd9, 0x1e, 0x4b, 0xac, 0xf6, 0xf7, 0x1b, 0x50, 0xc1, 0x3d, 0x94, 0x0b,
	0x7e, 0x0f, 0xc0, 0x1f, 0x7a, 0x2f, 0xfa, 0x7e, 0x4f, 0xbc, 0xb8, 0xac, 0xbd, 0x2b, 0x07, 0x5e,
	0x4f, 0x28, 0x47, 0x97, 0x38, 0x71, 0x2f, 0x88, 0x32, 0x7e, 0x4d, 0x4d, 0x9c, 0x92, 0x8e, 0x2e,
	0xe7, 0x6a, 0xfb, 0x00, 0x76, 0xbc, 0x7e, 0xec, 0x87, 0x43, 0x69, 0x0a, 0x81, 0xb4, 0x28, 0x77,
	0xa4, 0x8c, 0x61, 0x21, 0x7d, 0xda, 0x49, 0x96, 0xca, 0x4e, 0x72, 0x0f, 0xb6, 0xb3, 0x0f, 0x31,
	0x1a, 0xfa, 0xa3, 0xb3, 0xda, 0xa6, 0x9c, 0xa9, 0x9a, 0x91, 0x6d, 0xa4, 0x4e, 0x03, 0xbd, 0xe1,
	0xe5, 0xe8, 0xac, 0x76, 0xad, 0x04, 0xd4, 0x91, 0x9a, 0xbb, 0xdd, 0xb2, 0x54, 0x28, 0x71, 0xbb,
	0x92, 0x81, 0xe9, 0x8c, 0x81, 0x33, 0x80, 0x3a, 0x40, 0xdb, 0x72, 0x6c, 0xc8, 0x4d, 0x3b, 0x7f,
	0x07, 0x56, 0xe6, 0xee, 0x00, 0xfd, 0x25, 0xac, 0x2b, 0xec, 0x24, 0xec, 0xd7, 0xaa, 0x07, 0x0b,
	0xf7, 0x37, 0x1e, 0xee, 0x97, 0x9c, 0x35, 0x71, 0x48, 0x5e, 0x91, 0xc0, 0x4e, 0xd8, 0xa7, 0x3f,
	0x00, 0x51, 0x42, 0x05, 0x47, 0xdf, 0x90, 0xb2, 0x77, 0x5e, 0xe3, 0xe8, 0x78, 0x3a, 0x12, 0x05,
	0xda, 0x99, 0x1c, 0xd5, 0x60, 0x2b, 0x3d, 0x65, 0x5d, 0xd1, 0x8d, 0xa2, 0xda, 0x4d, 0x69, 0xf8,
	0xf4, 0x98, 0x75, 0xeb, 0x51, 0x44, 0x3f, 0x4e, 0x17, 0x84, 0x98, 0xe8, 0xe2, 0x5c, 0xe2, 0x6e,
	0x49, 0x5c, 0x35, 0xc5, 0x39, 0x17, 0xe7, 0x08, 0x35, 0x80, 0x78, 0xbd, 0x5e, 0x12, 0x61, 0xe2,
	0x91, 0x88, 0xfc, 0xb8, 0x76, 0xfd, 0x60, 0xe1, 0x7e, 0xf5, 0xe1, 0x41, 0x49, 0xb5, 0xd4, 0xef,
	0x0e, 0x65, 0xe0, 0x71, 0xfc, 0x98, 0x6f, 0x79, 0xbd, 0x9e, 0xfc, 0x70, 0x47, 0x8e, 0x1f, 0xd3,
	0x63, 0x50, 0xca, 0xaa, 0xcd, 0x96, 0x23, 0xdd, 0x78, 0xdb, 0x91, 0xa4, 0xa0, 0x74, 0x07, 0x1c,
	0xe9, 0x1b, 0x58, 0x8b, 0x55, 0x10, 0xac, 0x11, 0x69, 0xa6, 0xdb, 0x73, 0x46, 0x28, 0x84, 0x49,
	0x9e, 0xc2, 0xe9, 0x97, 0xb0, 0x8f, 0x1e, 0x8e, 0x87, 0xd4, 0xef, 0x4d, 0xc5, 0xcd, 0x55, 0xb9,
	0x9f, 0x7b, 0x39, 0xb7, 0x10, 0x3f, 0x0f, 0x60, 0xa3, 0xe7, 0x8f, 0x43, 0xbf, 0x2b, 0x8f, 0x71,
	0x6d, 0x4d, 0x42, 0x8b, 0x24, 0xf4, 0xd1, 0xc2, 0xa7, 0xdc, 0xfc, 0x8a, 0xf2, 0xd1, 0x02, 0x19,
	0xb7, 0xba, 0x09, 0xdb, 0xdd, 0x28, 0x12, 0xbd, 0x3c, 0x2a, 0xd4, 0xf6, 0x64, 0x48, 0x7b, 0xaf,
	0xb4, 0x84, 0xe9, 0xd0, 0xc1, 0xab, 0xdd, 0xe9, 0x50, 0x72, 0x0a, 0x9b, 0xbd, 0x20, 0x1a, 0x7b,
	0x71, 0xf7, 0xa5, 0xf8, 0xd1, 0xbf, 0xac, 0x6d, 0x49, 0x4b, 0xde, 0xbb, 0xca, 0x92, 0x8d, 0x04,
	0xfb, 0xc4, 0xbf, 0x74, 0x2f, 0xc7, 0xfe, 0xa3, 0x2d, 0xcb, 0xb6, 0x98, 0x68, 0x18, 0x4e, 0x5b,
	0x77, 0xeb, 0xc7, 0x7c, 0xa3, 0x97, 0xf3, 0xe9, 0xfb, 0x50, 0x09, 0x06, 0xe3, 0x7e, 0xd0, 0x0d,
	0xe2, 0xda, 0x4e, 0x31, 0xb8, 0x65, 0x64, 0xfa, 0x29, 0xd0, 0x2c, 0x97, 0xf8, 0xaf, 0x62, 0x7f,
	0x18, 0xe1, 0x42, 0x76, 0xe5, 0xd1, 0xda, 0x49, 0x39, 0x2c, 0x65, 0xd0, 0x1f, 0x60, 0x27, 0x4f,
	0x3d, 0xc3, 0xae, 0x1f, 0xc5, 0xa3, 0xb0, 0xb6, 0x2f, 0x77, 0xae, 0xbc, 0x6c, 0x3d, 0x61, 0xb7,
	0xbc, 0xf0, 0x47, 0x3f, 0xe4, 0x24, 0x95, 0x4b, 0xe9, 0x5a, 0x13, 0x2a, 0xa9, 0x5b, 0xd0, 0x3d,
	0x20, 0x1d, 0xeb, 0x89, 0x65, 0x3f, 0xb3, 0xc4, 0x89, 0x6e, 0x76, 0x98, 0xc3, 0x5c, 0xf2, 0x0e,
	0x25, 0xb0, 0xe9, 0xb2, 0x56, 0xdb, 0xd4, 0x5d, 0x26, 0x8c, 0x86, 0x43, 0x16, 0x28, 0x85, 0xaa,
	0xde, 0x6a, 0x0b, 0xa7, 0xce, 0x8d, 0xb6, 0x2b, 0x69, 0x8b, 0xda, 0x18, 0xb6, 0x4b, 0x46, 0xa1,
	0x3b, 0x30, 0x6d, 0x16, 0xf2, 0x8e, 0x24, 0xe9, 0xad, 0x02, 0x69, 0x81, 0xbe, 0x0b, 0xbb, 0x92,
	0x24, 0x67, 0xcc, 0x19, 0x8b, 0xf4, 0x36, 0xdc, 0x28, 0x30, 0xda, 0x3a, 0x67, 0x96, 0x9b, 0xf3,
	0x97, 0xb4, 0x96, 0x8a, 0xcd, 0x32, 0xa9, 0xcd, 0x8b, 0xad, 0x9f, 0xc2, 0x0a, 0xe6, 0x65, 0x15,
	0x4f, 0x37, 0x1e, 0xbe, 0x7b, 0xc5, 0x5e, 0x72, 0x85, 0xd2, 0x7e, 0x0d, 0x3b, 0x0d, 0x3f, 0xea,
	0xfa, 0xc3, 0x9e, 0x37, 0x8c, 0x5d, 0xef, 0xfc, 0xca, 0x71, 0x09, 0x2c, 0xc5, 0xde, 0x79, 0x12,
	0xa5, 0xf1, 0x4f, 0xed, 0x0c, 0xb6, 0x0b, 0xbe, 0x74, 0xa5, 0xe0, 0xf7, 0xe8, 0xf6, 0xb9, 0x9f,
	0x2e, 0xbe, 0x8d, 0x9f, 0x16, 0x25, 0xb4, 0xa7, 0xb0, 0xd7, 0xc8, 0xce, 0x53, 0xbd, 0xe1, 0xc5,
	0x9e, 0x3a, 0x4f, 0x7b, 0xb0, 0x52, 0x2c, 0x56, 0xd4, 0x07, 0xfd, 0x00, 0xb6, 0xfc, 0x30, 0x1c,
	0x85, 0x62, 0xe0, 0x47, 0x91, 0x77, 0xae, 0x72, 0xf0, 0x3a, 0xdf, 0x94, 0xc4, 0x96, 0xa2, 0x69,
	0x03, 0xa8, 0xb6, 0xfc, 0x5e, 0xe0, 0x3d, 0x9d, 0xf8, 0xa1, 0x2a, 0x4f, 0x3e, 0x85, 0xed, 0x20,
	0x8a, 0x26, 0xe8, 0x5a, 0x91, 0x90, 0x58, 0x39, 0x6c, 0xe6, 0xb5, 0x5b, 0x8a, 0xab, 0x47, 0x0c,
	0x79, 0xb8, 0xd0, 0xf8, 0x72, 0xec, 0x27, 0xe6, 0x90, 0x7f, 0xd3, 0x1a, 0xac, 0x9d, 0xf9, 0x5e,
	0x3c, 0x09, 0xb1, 0x62, 0x41, 0x72, 0xfa, 0xa9, 0xfd, 0x0d, 0x6c, 0x3a, 0x7e, 0xdf, 0xef, 0xc6,
	0x23, 0x95, 0x53, 0x3f, 0x84, 0x2a, 0x5a, 0x3f, 0x78, 0x31, 0x89, 0x55, 0xf6, 0x4b, 0x4a, 0x89,
	0xad, 0x8c, 0x8a, 0xa9, 0x0f, 0x4b, 0x9d, 0x71, 0xe4, 0x4f, 0x7a, 0x23, 0xd1, 0xed, 0x7b, 0x51,
	0x9a, 0x21, 0x37, 0x14, 0xad, 0x8e, 0x24, 0x1c, 0x29, 0x81, 0xf8, 0x7d, 0x7f, 0xe0, 0x0f, 0xe3,
	0x64, 0xea, 0x2d, 0x45, 0x65, 0x8a, 0xa8, 0x05, 0x00, 0x7a, 0xcc, 0x27, 0x7d, 0xff, 0xca, 0x52,
	0xec, 0x31, 0x90, 0x01, 0x5a, 0x44, 0xfc, 0x84, 0x26, 0x11, 0xd1, 0xd8, 0xef, 0xca, 0x64, 0x3b,
	0xbb, 0x55, 0xd3, 0x86, 0xe3, 0xd5, 0xc1, 0xd4, 0xb7, 0xf6, 0xcf, 0x8b, 0xb0, 0x56, 0x8f, 0x22,
	0x39, 0xd1, 0x6f, 0x60, 0xd3, 0x8b, 0x45, 0x38, 0xe9, 0xfb, 0x6a, 0x40, 0x55, 0x76, 0x5d, 0x9f,
	0x71, 0xc9, 0x54, 0x33, 0x0e, 0x5e, 0xae, 0xe5, 0xc7, 0x32, 0x9d, 0x21, 0xc6, 0x17, 0xde, 0x60,
	0xfc, 0xa5, 0xd7, 0x8b, 0x64, 0xba, 0xac, 0xf0, 0xb4, 0xc2, 0xf5, 0x75, 0x45, 0xc6, 0x40, 0x92,
	0x41, 0x7f, 0xf4, 0x2f, 0xcf, 0x42, 0x59, 0x50, 0xac, 0x4a, 0xf0, 0x4e, 0xca, 0x79, 0x92, 0x32,
	0x54, 0x20, 0xce, 0x3d, 0x72, 0x4d, 0x99, 0xb5, 0x40, 0xa2, 0x87, 0xb0, 0xad, 0x8a, 0xb3, 0x60,
	0x30, 0x1e, 0x85, 0xb1, 0x37, 0x8c, 0x65, 0x20, 0xce, 0xbc, 0x41, 0xd5, 0x79, 0x46, 0xca, 0xa4,
	0xbf, 0x83, 0xad, 0x28, 0xd9, 0x60, 0xb5, 0xd2, 0x75, 0x69, 0xba, 0x72, 0x81, 0x59, 0x74, 0x02,
	0xbe, 0x19, 0x15, 0xbe, 0xb4, 0xff, 0x5e, 0x84, 0xf5, 0x7a, 0xcf, 0x8b, 0x3d, 0xb9, 0xf6, 0x3b,
	0x58, 0xf3, 0xbc, 0x12, 0x2f, 0x2e, 0x63, 0x59, 0xac, 0x2e, 0xdc, 0x5f, 0x79, 0xb4, 0xf8, 0xe9,
	0x43, 0x5e, 0x19, 0x78, 0xaf, 0x8e, 0x90, 0x46, 0x1f, 0x00, 0xcd, 0x00, 0x72, 0x46, 0x99, 0x2c,
	0x94, 0xab, 0x6f, 0xa7, 0x28, 0x1c, 0x0a, 0xb3, 0xc5, 0x54, 0xe9, 0xd3, 0xc5, 0x49, 0x92, 0xca,
	0x2f, 0x2f, 0x7d, 0xe4, 0xd4, 0x58, 0xc3, 0x48, 0xf6, 0x54, 0x32, 0x03, 0x49, 0x52, 0x47, 0xee,
	0x0b, 0xa8, 0x60, 0xde, 0x91, 0x4b, 0x5c, 0x9b, 0x5b, 0x96, 0x24, 0x5b, 0xcf, 0xd7, 0xba, 0x89,
	0x0f, 0xdc, 0x83, 0xed, 0x9f, 0x5f, 0x06, 0xb1, 0x1f, 0x8d, 0xbd, 0x2e, 0x26, 0xed, 0xfe, 0xa5,
	0x32, 0x25, 0xaf, 0xe6, 0x64, 0x7b, 0xd8, 0xbf, 0xa4, 0xa7, 0x53, 0x49, 0xb5, 0xa8, 0xc7, 0xb2,
	0x74, 0x9b, 0x0f, 0x4a, 0x33, 0xcd, 0x8b, 0x09, 0xc5, 0xcc, 0x5b, 0xcf, 0xd5, 0xd6, 0x60, 0x2b,
	0xa9, 0x63, 0x12, 0x93, 0x6e, 0xa8, 0x6a, 0xa6, 0x27, 0x0b, 0x19, 0x69, 0x2b, 0xed, 0xdf, 0x17,
	0x61, 0x5d, 0x1f, 0x8c, 0x4d, 0xef, 0x72, 0x34, 0x89, 0xa9, 0x09, 0x3b, 0xd1, 0x64, 0x8c, 0xdb,
	0xeb, 0xf7, 0x44, 0x5f, 0xd2, 0xd4, 0xad, 0xa1, 0x3a, 0x53, 0x4c, 0x65, 0x42, 0x87, 0xea, 0x1f,
	0x4e, 0x32, 0x49, 0x45, 0x88, 0xe8, 0x43, 0xb8, 0xd6, 0xf3, 0xcf, 0x82, 0xa1, 0x8f, 0x29, 0xfb,
	0xcc, 0x9b, 0xf4, 0x63, 0xf1, 0x73, 0xd0, 0x8b, 0x5f, 0x26, 0x77, 0x9e, 0xdd, 0x84, 0xd9, 0x50,
	0xbc, 0x67, 0xc8, 0x92, 0x35, 0x46, 0x49, 0xe6, 0xa5, 0x1f, 0x9c, 0xbf, 0x8c, 0x93, 0x1a, 0x78,
	0x6f, 0x5a, 0xe8, 0x58, 0xf2, 0xb4, 0xbf, 0x5b, 0x80, 0xd5, 0x64, 0x09, 0x5b, 0xb0, 0x5e, 0xb7,
	0x2d, 0x57, 0x37, 0x2c, 0xc6, 0xc9, 0x0a, 0xad, 0xc0, 0x72, 0xd3, 0x30, 0x4d, 0xb2, 0x4a, 0xd7,
	0x61, 0xa5, 0x69, 0x3c, 0x67, 0x0d, 0xb2, 0x88, 0x49, 0x4e, 0xfe, 0x29, 0x8e, 0x99, 0xf1, 0xf8,
	0xd8, 0x25, 0x4b, 0x28, 0xd5, 0x34, 0xd9, 0x73, 0x61, 0xb8, 0xac, 0x45, 0xd6, 0x24, 0xd6, 0xec,
	0x18, 0x0d, 0x52, 0x41, 0x8e, 0x61, 0xb9, 0xdc, 0xb0, 0x1c, 0xa3, 0x4e, 0xd6, 0xf1, 0xd3, 0xb2,
	0x31, 0x2f, 0x99, 0xfa, 0x29, 0x59, 0xa0, 0x55, 0x00, 0xce, 0x9c, 0xb6, 0x6d, 0x39, 0xc6, 0x09,
	0x23, 0xcb, 0x74, 0x03, 0xd6, 0x92, 0xa4, 0x4a, 0xde, 0xd1, 0x26, 0x50, 0x9d, 0xce, 0xc8, 0xf4,
	0x5b, 0x58, 0x1d, 0xc8, 0xbf, 0x12, 0xa3, 0xde, 0x7d, 0x6d, 0x02, 0x3f, 0x4c, 0xf2, 0x78, 0x22,
	0xa3, 0x7d, 0x08, 0xab, 0xc9, 0x38, 0xc5, 0x69, 0x50, 0x07, 0xbd, 0xe3, 0xda, 0x4e, 0x9d, 0xdb,
	0xa6, 0x49, 0x16, 0xb4, 0xff, 0x5a, 0x80, 0xcd, 0xfa, 0xcb, 0xa0, 0xdf, 0x73, 0xbd, 0xf3, 0x24,
	0x1e, 0xd5, 0xf2, 0x83, 0x30, 0x9c, 0x0c, 0x44, 0x17, 0xb9, 0x22, 0xf6, 0xce, 0xf3, 0x53, 0xf6,
	0x05, 0xbf, 0x96, 0x61, 0xac, 0xc9, 0x20, 0x95, 0x8f, 0xe8, 0x23, 0xb8, 0x71, 0x16, 0x84, 0x51,
	0x9c, 0x0b, 0xc9, 0xd0, 0x9d, 0x5c, 0x3a, 0x54, 0x6c, 0xde, 0x97, 0x88, 0x54, 0x06, 0x83, 0xb8,
	0xba, 0x7c, 0x7c, 0x06, 0x7b, 0x73, 0xa5, 0x54, 0xb0, 0xde, 0xe9, 0xce, 0x08, 0x1c, 0xc1, 0xad,
	0x5c, 0xd3, 0x41, 0x30, 0x2c, 0x6b, 0xbb, 0x9c, 0x69, 0x9b, 0xaf, 0xa8, 0x15, 0x0c, 0x8b, 0x0a,
	0x6b, 0x7f, 0x82, 0x2a, 0xf7, 0xcf, 0xfc, 0xd0, 0x1f, 0x76, 0xfd, 0xf6, 0x28, 0x18, 0xc6, 0x78,
	0x0e, 0x50, 0x01, 0x19, 0x2f, 0x0a, 0x19, 0x60, 0x23, 0x56, 0xf6, 0xb1, 0xde, 0x7c, 0x27, 0xdf,
	0x87, 0xd5, 0xc9, 0x30, 0xf8, 0x29, 0xb9, 0x94, 0x57, 0x78, 0xf2, 0xa5, 0xfd, 0xcb, 0x32, 0x6c,
	0x65, 0x95, 0xda, 0x95, 0x49, 0xa6, 0x06, 0x6b, 0x17, 0x7e, 0x18, 0xa5, 0x65, 0xc0, 0x3a, 0x4f,
	0x3f, 0xe5, 0xad, 0x5e, 0xfd, 0xa9, 0x14, 0x5b, 0x57, 0x8a, 0x25, 0x34, 0x4b, 0x15, 0x36, 0x34,
	0xad, 0x82, 0xb1, 0xe8, 0x4e, 0xc6, 0x49, 0x2c, 0x98, 0x73, 0x4e, 0x92, 0x11, 0x3d, 0xa8, 0x66,
	0x35, 0xa5, 0x90, 0xb9, 0xba, 0x22, 0x8b, 0xdb, 0x4f, 0x4a, 0x9e, 0x36, 0xa5, 0x75, 0xfe, 0x25,
	0xeb, 0xdb, 0x6a, 0xbd, 0xe3, 0xb8, 0x76, 0x4b, 0x30, 0x93, 0xb5, 0x98, 0xe5, 0xf2, 0x2d, 0xbf,
	0xc8, 0xa6, 0x0c, 0x6e, 0x16, 0x34, 0x52, 0x09, 0xa3, 0x37, 0xc1, 0xe2, 0xd6, 0x8b, 0xd3, 0xfc,
	0x93, 0x66, 0x8c, 0xeb, 0x39, 0x52, 0x47, 0x60, 0x23, 0xc3, 0xd1, 0x1e, 0x54, 0xb3, 0xba, 0x76,
	0x22, 0x4b, 0x96, 0x35, 0xa9, 0xe9, 0x57, 0x6f, 0xa7, 0x69, 0x07, 0x45, 0x92, 0xd6, 0x0b, 0x26,
	0xfb, 0x47, 0x2b, 0x8c, 0x73, 0x9b, 0xf3, 0xad, 0x74, 0x50, 0x09, 0xd0, 0x9e, 0x15, 0x36, 0x48,
	0x6a, 0x3f, 0x75, 0x74, 0x28, 0x94, 0xd6, 0x4a, 0x16, 0xe8, 0x2e, 0x6c, 0x27, 0xb4, 0xb4, 0x10,
	0x56, 0x11, 0xe3, 0xd8, 0x76, 0x5c, 0xe1, 0x30, 0x7e, 0x62, 0xd4, 0x19, 0x59, 0xd2, 0xbe, 0x83,
	0xeb, 0x57, 0xea, 0x82, 0xf1, 0x43, 0x6a, 0x43, 0x16, 0xe8, 0x26, 0x54, 0xd8, 0x73, 0xd6, 0x6a,
	0xbb, 0x32, 0xf2, 0x54, 0x60, 0x19, 0xab, 0x64, 0xb2, 0xa4, 0xfd, 0x01, 0xe0, 0x38, 0x1e, 0xf4,
	0x9b, 0xa3, 0x70, 0xe0, 0xc5, 0x9a, 0x0d, 0xcb, 0xf5, 0x51, 0x0f, 0xcb, 0xcd, 0xcd, 0xb4, 0x28,
	0xaf, 0xdb, 0x0d, 0x46, 0xde, 0xa1, 0x6b, 0xb0, 0xa4, 0xb7, 0xda, 0x64, 0x01, 0x15, 0xd7, 0x5b,
	0xed, 0x2f, 0x75, 0x2c, 0xc0, 0x31, 0x0c, 0xe1, 0x07, 0x6b, 0xe9, 0x86, 0x49, 0x96, 0x50, 0x8c,
	0x3d, 0x6f, 0x33, 0x6e, 0xe0, 0x1a, 0x74, 0x93, 0x2c, 0x6b, 0xff, 0xba, 0x05, 0x6b, 0xe9, 0xf9,
	0xff, 0x1e, 0x36, 0x5e, 0xc6, 0x83, 0xbe, 0x38, 0x93, 0x73, 0xd5, 0xae, 0xc9, 0xd0, 0x53, 0xbe,
	0xf5, 0xe5, 0xca, 0x1c, 0xa2, 0x26, 0x1c, 0x5e, 0x66, 0x84, 0x52, 0x33, 0xe4, 0x83, 0x37, 0x34,
	0x43, 0xee, 0xce, 0x34, 0x43, 0xae, 0x43, 0x25, 0x8d, 0x00, 0xc9, 0xc1, 0x58, 0x8b, 0xd5, 0xb1,
	0xa7, 0x37, 0x61, 0x3d, 0x3f, 0x97, 0x2a, 0x91, 0x57, 0xa2, 0xf4, 0x50, 0x7e, 0x0c, 0xa4, 0xe7,
	0x47, 0xdd, 0x30, 0x18, 0x67, 0x0d, 0x93, 0xda, 0x3d, 0x95, 0xec, 0x0b, 0x74, 0x09, 0x3d, 0x82,
	0x0a, 0xb2, 0x7b, 0x22, 0xe8, 0xd5, 0xde, 0x97, 0x7e, 0x54, 0x5e, 0x60, 0x62, 0x8d, 0x43, 0x84,
	0xf7, 0x8c, 0xde, 0xa3, 0x35, 0xcb, 0xc6, 0xfd, 0x74, 0xf9, 0xda, 0x50, 0x51, 0x68, 0xbd, 0x78,
	0x76, 0x64, 0xb2, 0xbf, 0x29, 0x93, 0xfd, 0xad, 0xd7, 0x79, 0x64, 0xe1, 0x74, 0x24, 0x15, 0xf5,
	0xbc, 0xdb, 0xdd, 0xad, 0xab, 0x6e, 0x77, 0xaf, 0x6f, 0xf3, 0xfc, 0x0a, 0xf6, 0x0b, 0xdd, 0x9b,
	0xbc, 0x45, 0xa4, 0x22, 0xe1, 0x7a, 0x21, 0x66, 0xeb, 0x05, 0x66, 0x21, 0x5c, 0xad, 0x14, 0xc3,
	0x15, 0x96, 0xcd, 0xea, 0x2f, 0xf1, 0xb3, 0x17, 0x0e, 0x83, 0xe1, 0xb9, 0xec, 0x46, 0x54, 0xf8,
	0x96, 0xa2, 0x3e, 0x53, 0x44, 0x34, 0x7b, 0x3e, 0xeb, 0xd8, 0x0b, 0xb1, 0xbe, 0x5e, 0x4d, 0x6b,
	0xac, 0x84, 0xde, 0x96, 0x64, 0x5c, 0x6d, 0xb1, 0xbd, 0x94, 0xdc, 0x4e, 0x55, 0x17, 0x68, 0xa7,
	0xd0, 0x61, 0x52, 0x0c, 0xfa, 0x0c, 0xee, 0xcf, 0xc2, 0x45, 0x34, 0x39, 0x3f, 0xf7, 0x23, 0x15,
	0x4c, 0xb2, 0x55, 0xc8, 0xe6, 0xc4, 0x3a, 0xff, 0x70, 0x66, 0x10, 0x27, 0x45, 0x17, 0x96, 0x4c,
	0x3f, 0x83, 0xdd, 0x42, 0x15, 0x95, 0x29, 0xb2, 0x25, 0xcd, 0x4e, 0x73, 0x56, 0xa6, 0xc9, 0x21,
	0xec, 0xf6, 0xb2, 0x0b, 0xa0, 0xcc, 0x4f, 0xfd, 0x20, 0x8a, 0x6b, 0xef, 0x29, 0xcd, 0x7b, 0x33,
	0x77, 0xc3, 0x5f, 0xc3, 0xf5, 0xe9, 0x2e, 0x30, 0x8a, 0xa4, 0x56, 0xdc, 0x57, 0x59, 0xb0, 0xd8,
	0x0c, 0x76, 0xbd, 0xf3, 0xd4, 0x9c, 0xb7, 0x60, 0x3d, 0xf2, 0xe2, 0x20, 0x3a, 0x0b, 0xfc, 0x28,
	0xed, 0x24, 0x66, 0x04, 0x7a, 0x03, 0x2a, 0xe9, 0x98, 0x49, 0x1b, 0x31, 0xfb, 0x46, 0x9e, 0xff,
	0xaa, 0xdb, 0x9f, 0xf4, 0xfc, 0xa8, 0x76, 0xa0, 0x78, 0xe9, 0x77, 0xb9, 0xad, 0xb2, 0xf3, 0x56,
	0x6d, 0x15, 0x3a, 0xb7, 0xad, 0xf2, 0x2b, 0xd8, 0xf5, 0x5f, 0xa9, 0xe6, 0x84, 0x6c, 0x6e, 0x47,
	0xaa, 0x5e, 0xd5, 0x8a, 0x81, 0x7c, 0x27, 0x45, 0xe0, 0x4d, 0x3a, 0x92, 0x95, 0x6b, 0x76, 0xe5,
	0x5e, 0x7b, 0x9b, 0x2b, 0x37, 0x06, 0x11, 0xfc, 0x43, 0xda, 0x39, 0xaa, 0x55, 0x94, 0x1d, 0xbc,
	0xe4, 0x4e, 0x1f, 0xd1, 0x43, 0x58, 0x51, 0x35, 0xfa, 0xa6, 0x3c, 0x73, 0xb5, 0x72, 0x81, 0x9d,
	0x5e, 0x12, 0xb8, 0x82, 0xd1, 0x47, 0x00, 0x85, 0xc2, 0x60, 0x77, 0xee, 0xc5, 0xa3, 0x58, 0x05,
	0xf1, 0xf5, 0x6e, 0x56, 0xd3, 0x7c, 0x05, 0xbb, 0x51, 0xf0, 0xa2, 0x1f, 0x0c, 0xcf, 0x23, 0x91,
	0xfb, 0x46, 0xed, 0x76, 0x71, 0xc1, 0x34, 0x45, 0xe4, 0x05, 0x37, 0xfd, 0x1a, 0xf6, 0x72, 0xf7,
	0xed, 0x7b, 0x69, 0x51, 0x54, 0xbb, 0x33, 0x25, 0x98, 0x41, 0x4c, 0x2f, 0x29, 0x8a, 0xe8, 0x31,
	0x90, 0x30, 0xad, 0x49, 0xc4, 0x18, 0x8b, 0x92, 0xe8, 0x8a, 0xce, 0xd5, 0x74, 0xe9, 0xc2, 0xb7,
	0xc3, 0xa9, 0xef, 0x08, 0x43, 0x69, 0x76, 0xef, 0x01, 0x15, 0x4a, 0xa3, 0xe4, 0xbe, 0xf3, 0x35,
	0x80, 0x37, 0x18, 0x27, 0x65, 0x7b, 0xd2, 0x02, 0xad, 0x5d, 0x55, 0xb5, 0xf3, 0x75, 0x2f, 0xab,
	0xfa, 0x8f, 0xf1, 0xbc, 0x87, 0x3f, 0x8a, 0xdc, 0xeb, 0xa3, 0xda, 0x47, 0x6f, 0xd3, 0x60, 0xda,
	0x46, 0xb1, 0xbc, 0x8f, 0x12, 0x69, 0x4d, 0x58, 0x4b, 0xc2, 0x2b, 0xa6, 0xab, 0x24, 0xc0, 0x92,
	0x77, 0x68, 0x0d, 0xf6, 0x4c, 0xc3, 0x7a, 0x22, 0x9a, 0xb6, 0xe5, 0x0a, 0xc7, 0x3d, 0x35, 0x99,
	0x73, 0xcc, 0x18, 0x66, 0xdb, 0x3d, 0x20, 0xf2, 0x5b, 0xe8, 0xad, 0xb6, 0x50, 0x79, 0x97, 0x2c,
	0x6a, 0xff, 0xb6, 0x00, 0x6b, 0x8d, 0x51, 0x77, 0x5e, 0xf6, 0x5a, 0xf8, 0x3f, 0x66, 0xaf, 0xc5,
	0x37, 0x64, 0xaf, 0xa5, 0x99, 0xec, 0x35, 0x75, 0x2b, 0x5d, 0x7e, 0xeb, 0x5b, 0xe9, 0xca, 0xdc,
	0x5b, 0xa9, 0xf6, 0x4f, 0x6b, 0x00, 0xaa, 0x93, 0xfc, 0xff, 0x63, 0x75, 0x45, 0x87, 0x5a, 0x9e,
	0x76, 0xa8, 0xaf, 0xd0, 0xdd, 0xd3, 0x75, 0x05, 0x51, 0x16, 0xee, 0xe8, 0x54, 0x60, 0x48, 0x17,
	0x68, 0x44, 0x69, 0xc0, 0x9b, 0x32, 0xd8, 0xca, 0x1c, 0x83, 0x7d, 0x07, 0x37, 0xf2, 0x81, 0xc7,
	0x7e, 0x28, 0x82, 0x61, 0x3f, 0x18, 0xfa, 0x22, 0x8a, 0x2f, 0xfb, 0xbe, 0x4c, 0x35, 0xaa, 0xc8,
	0xdf, 0x4f, 0x25, 0xda, 0x7e, 0x68, 0x48, 0x88, 0x83, 0x08, 0xfa, 0x10, 0xe8, 0x24, 0xec, 0xa7,
	0x8a, 0x0d, 0x65, 0x44, 0xec, 0xc9, 0xf2, 0x31, 0x7d, 0x75, 0x22, 0x93, 0xb0, 0xaf, 0xb4, 0x4a,
	0xb8, 0x57, 0x6c, 0x52, 0x65, 0x7e, 0xeb, 0xc0, 0x80, 0xdb, 0xaa, 0xae, 0xf5, 0xfa, 0xfd, 0x62,
	0xbb, 0x59, 0x04, 0xc3, 0x44, 0x49, 0x28, 0xda, 0xe0, 0x86, 0x04, 0xeb, 0xfd, 0x7e, 0xa1, 0x99,
	0x67, 0x0c, 0x95, 0xae, 0x5f, 0xc2, 0xbe, 0xff, 0x6a, 0xec, 0x0d, 0xb1, 0x76, 0x1f, 0xf6, 0x46,
	0xa1, 0x18, 0x87, 0xfe, 0x59, 0xf0, 0xca, 0x57, 0x31, 0xab, 0xc2, 0xf7, 0x14, 0xf7, 0x44, 0x32,
	0xdb, 0x09, 0xaf, 0xdc, 0x3d, 0xdc, 0xf8, 0xdf, 0x76, 0x0f, 0x69, 0x13, 0x83, 0x7f, 0xae, 0x77,
	0x74, 0x71, 0x5e, 0xdb, 0x7c, 0xab, 0x56, 0x79, 0x41, 0xca, 0xb9, 0x38, 0x57, 0x25, 0x58, 0x3e,
	0x8e, 0x4c, 0x92, 0x2a, 0xab, 0x16, 0xc7, 0x97, 0x29, 0xf2, 0x73, 0xd8, 0x2b, 0x43, 0xe5, 0xbc,
	0xd5, 0x24, 0x09, 0x4f, 0xc3, 0x71, 0xf0, 0x6f, 0xa1, 0x1a, 0x0c, 0xbc, 0x73, 0xf9, 0xde, 0xa3,
	0x0a, 0xae, 0xed, 0xd7, 0x3e, 0xfa, 0x6c, 0x4a, 0x74, 0xfa, 0x26, 0xf9, 0x08, 0xb6, 0xce, 0x46,
	0xc3, 0x38, 0x17, 0x26, 0xaf, 0x15, 0xde, 0x40, 0x70, 0x2a, 0x3b, 0xa7, 0xd3, 0xb5, 0xf3, 0x9a,
	0x4e, 0x97, 0xf6, 0x9f, 0x2b, 0x50, 0x3d, 0x49, 0x87, 0xe4, 0x93, 0xbe, 0x1f, 0xd1, 0x4f, 0x60,
	0x39, 0xb9, 0x41, 0x2f, 0xcd, 0x99, 0x35, 0xcd, 0x3a, 0x12, 0x43, 0xbf, 0x9a, 0xca, 0x7d, 0x57,
	0xe7, 0x4b, 0xf9, 0x2a, 0x55, 0x48, 0x8a, 0x0c, 0xee, 0xe0, 0x2d, 0x38, 0x03, 0x89, 0xd0, 0xbf,
	0x08, 0x64, 0x79, 0x9a, 0xd4, 0x08, 0x3d, 0x15, 0x90, 0xf8, 0xad, 0x41, 0x30, 0xcc, 0xf5, 0x4b,
	0x40, 0x49, 0x2d, 0xd2, 0xa3, 0x9f, 0x03, 0x95, 0x1e, 0x7f, 0x16, 0xf4, 0xfd, 0x6c, 0x88, 0xc2,
	0x39, 0x23, 0xc8, 0x6d, 0x06, 0x7d, 0x3f, 0x95, 0xa4, 0x9f, 0xc0, 0x4e, 0xec, 0x0f, 0xc6, 0x7d,
	0x2f, 0xf6, 0x67, 0x0e, 0x4b, 0xca, 0x48, 0x0f, 0xcb, 0x47, 0xb0, 0x2d, 0xcf, 0x44, 0xe1, 0x58,
	0xa9, 0x02, 0x70, 0x4b, 0x91, 0x8b, 0x38, 0x59, 0xb3, 0xe7, 0xb8, 0x9d, 0x04, 0x27, 0xc9, 0x29,
	0xee, 0xfb, 0xb4, 0x95, 0xad, 0x62, 0x62, 0x54, 0x5b, 0x97, 0xf6, 0xba, 0x51, 0xae, 0xc2, 0x11,
	0xa3, 0x82, 0x60, 0xd2, 0xe6, 0x56, 0x1f, 0x11, 0x35, 0x61, 0x47, 0x0d, 0x80, 0xf3, 0x04, 0x67,
	0x58, 0xb5, 0x5c, 0x4a, 0xa7, 0x9d, 0x7d, 0x12, 0x94, 0x83, 0x38, 0x39, 0x8c, 0x13, 0xbf, 0x44,
	0xa1, 0xed, 0xf9, 0x95, 0x22, 0x91, 0xe3, 0x95, 0x5f, 0xdf, 0x66, 0x1e, 0x15, 0xe6, 0xd5, 0x92,
	0xf7, 0x61, 0xa9, 0x37, 0xea, 0xca, 0x7b, 0xd8, 0xac, 0xe3, 0x24, 0x69, 0x8f, 0x23, 0x84, 0x3e,
	0x80, 0xa5, 0x6e, 0x14, 0xc9, 0xb7, 0xa1, 0xd9, 0x06, 0x72, 0x9e, 0x45, 0x38, 0xa2, 0xa8, 0x31,
	0xe7, 0xa8, 0xaa, 0x22, 0xe3, 0xf6, 0x8c, 0x96, 0x53, 0x47, 0x71, 0xe6, 0x28, 0x6b, 0x77, 0x61,
	0x4b, 0x5a, 0xa6, 0xee, 0xc5, 0xfe, 0xf9, 0x28, 0xbc, 0xd4, 0x76, 0x93, 0xfb, 0xe9, 0x54, 0x7f,
	0xeb, 0x6f, 0x35, 0xd8, 0x4e, 0x9c, 0x2e, 0x18, 0x0d, 0xd5, 0x0b, 0xc1, 0x0f, 0x50, 0x89, 0xfc,
	0x0b, 0x3f, 0x44, 0x93, 0xaf, 0xce, 0x7d, 0x56, 0x2b, 0x49, 0x1c, 0x3a, 0x09, 0x3c, 0xbd, 0xc0,
	0x67, 0xf2, 0xf4, 0x6b, 0x58, 0xee, 0x8e, 0x7a, 0xea, 0xca, 0x58, 0x9d, 0x69, 0x84, 0x96, 0xc7,
	0x91, 0x99, 0x51, 0x0a, 0xd0, 0x6b, 0xb0, 0x8c, 0xc9, 0x42, 0xde, 0x27, 0x57, 0x1e, 0x2d, 0x7c,
	0xc1, 0xe5, 0x27, 0x25, 0xb0, 0xd4, 0x1d, 0xf5, 0xe5, 0x2d, 0x6b, 0x85, 0xe3, 0x9f, 0x53, 0xc9,
	0x6f, 0x65, 0x3a, 0xf9, 0xed, 0xc3, 0xea, 0xd8, 0x0b, 0xbd, 0x41, 0x94, 0x34, 0xca, 0x93, 0x2f,
	0xfa, 0x5b, 0xa8, 0x74, 0x13, 0xab, 0x24, 0xad, 0x95, 0xf7, 0xe7, 0xf9, 0x54, 0x6a, 0x39, 0xa5,
	0x56, 0x26, 0x42, 0x1f, 0xc1, 0x0d, 0xd9, 0xe2, 0xc5, 0x4a, 0x2d, 0xf4, 0x31, 0xbc, 0x88, 0xd8,
	0x8f, 0x62, 0xf5, 0x9a, 0x9a, 0xf4, 0x7f, 0xf6, 0x11, 0xa1, 0x0f, 0xc6, 0x5c, 0xf2, 0x5d, 0x3f,
	0x8a, 0xe5, 0xa3, 0x9d, 0xf6, 0x0d, 0x54, 0x52, 0x63, 0x15, 0x5f, 0xef, 0x1c, 0x76, 0xc2, 0xb8,
	0xe1, 0x9e, 0x92, 0x77, 0x8a, 0x7d, 0x87, 0x0d, 0x58, 0x7b, 0xa6, 0x73, 0xcb, 0xb0, 0x1e, 0x93,
	0x65, 0xed, 0x3f, 0x6e, 0x5f, 0xd9, 0x5f, 0xa8, 0xc1, 0x9e, 0x61, 0x9d, 0xe8, 0xa6, 0xd1, 0x10,
	0x0d, 0xbb, 0xee, 0x9e, 0xb6, 0x99, 0x38, 0x76, 0x5b, 0x26, 0x19, 0xd1, 0xeb, 0x70, 0xad, 0xa5,
	0x5b, 0x0d, 0xdd, 0xb5, 0xf9, 0xa9, 0x70, 0xf5, 0xc7, 0xa2, 0x65, 0x38, 0x0e, 0x8e, 0xb7, 0x40,
	0x6f, 0xc2, 0xbb, 0x48, 0xe0, 0xec, 0x69, 0xc7, 0xe0, 0xac, 0x21, 0x8e, 0x4e, 0x33, 0x66, 0x8d,
	0x7e, 0x00, 0x77, 0x92, 0x99, 0xc5, 0x55, 0x20, 0x93, 0xbe, 0x0b, 0xbb, 0xc8, 0x64, 0xcf, 0xeb,
	0x66, 0xa7, 0xa1, 0x98, 0xae, 0xfe, 0x98, 0xf8, 0xf4, 0x16, 0xd4, 0x52, 0x69, 0xf6, 0xdc, 0x65,
	0x96, 0x63, 0xd8, 0x96, 0xe8, 0x58, 0x1d, 0x87, 0x35, 0x88, 0x8d, 0xcb, 0x9e, 0xa1, 0xba, 0xf4,
	0x3e, 0xdc, 0x9d, 0x95, 0x69, 0xb0, 0x36, 0x67, 0x75, 0xdd, 0x65, 0x0d, 0x71, 0xc2, 0x38, 0x92,
	0x48, 0x1b, 0x47, 0xb7, 0x6c, 0x4b, 0x98, 0xae, 0x93, 0x3e, 0x68, 0xea, 0x4d, 0x97, 0x71, 0x24,
	0x90, 0x31, 0x72, 0x67, 0x38, 0x09, 0x9c, 0xfc, 0x44, 0xef, 0xc2, 0x81, 0x61, 0xd5, 0x6d, 0xce,
	0x59, 0xdd, 0x4d, 0x31, 0x9c, 0x99, 0x4c, 0x77, 0x58, 0x36, 0xc3, 0xcf, 0xf4, 0x3d, 0xb8, 0xae,
	0xbb, 0x2e, 0x2f, 0x2c, 0xbb, 0xe3, 0x66, 0xeb, 0xfe, 0x2d, 0xa5, 0x50, 0x6d, 0x18, 0x8e, 0x6e,
	0x9a, 0xf6, 0x33, 0xd6, 0x90, 0x4b, 0x5e, 0xa4, 0x37, 0x60, 0xff, 0x31, 0xb3, 0x18, 0xd7, 0x4d,
	0x51, 0xe2, 0xfd, 0x12, 0x37, 0xa1, 0x40, 0x4b, 0x66, 0x45, 0xd6, 0x73, 0xba, 0x0b, 0xdb, 0x05,
	0x16, 0x4e, 0x4a, 0x96, 0xca, 0x78, 0x55, 0x5a, 0x23, 0xeb, 0x29, 0xdd, 0x07, 0x9a, 0xee, 0xb4,
	0xd4, 0x50, 0x3e, 0xb5, 0x92, 0x65, 0xdc, 0x8a, 0x46, 0xa7, 0x6d, 0x1a, 0x68, 0x2b, 0xc9, 0x31,
	0x8e, 0x3a, 0x2e, 0x23, 0x7f, 0xa4, 0xef, 0xc3, 0x7b, 0x39, 0x70, 0x6a, 0x1f, 0x4d, 0xfd, 0xd4,
	0xee, 0xb8, 0xe4, 0x26, 0xae, 0x36, 0x59, 0x5b, 0x42, 0xcb, 0x07, 0x70, 0x48, 0x80, 0x2b, 0x33,
	0x5a, 0x6d, 0xd3, 0x60, 0x8d, 0x94, 0x9d, 0x68, 0x40, 0xf6, 0xd1, 0xd8, 0x4e, 0x9b, 0xd5, 0x8d,
	0xe6, 0x1c, 0xee, 0x0d, 0x94, 0xcc, 0x9d, 0x4f, 0x6a, 0x91, 0xda, 0x70, 0x85, 0x1e, 0xc0, 0xad,
	0x9c, 0x67, 0x5b, 0xcc, 0x6e, 0x4e, 0x23, 0x6e, 0x4d, 0x23, 0x74, 0xeb, 0xb4, 0x8c, 0x78, 0x39,
	0xbd, 0xe8, 0x86, 0xd1, 0x52, 0x4e, 0x43, 0xbe, 0xc5, 0xf3, 0x90, 0x33, 0x3a, 0x96, 0xf1, 0xb4,
	0xc3, 0xa4, 0xbd, 0x57, 0x71, 0xd0, 0x79, 0x1c, 0x91, 0x1e, 0xb3, 0x16, 0x7a, 0xe7, 0x33, 0x6e,
	0x5b, 0x8f, 0xd3, 0xf7, 0x6b, 0x94, 0x5b, 0xc3, 0xa9, 0xf2, 0x2b, 0x8f, 0x70, 0x6d, 0x5b, 0x98,
	0xb6, 0xf5, 0x98, 0x3c, 0x44, 0xb7, 0x2d, 0x30, 0x74, 0xab, 0x21, 0x0c, 0xcb, 0x34, 0x2c, 0x96,
	0x6c, 0x5b, 0x86, 0x3c, 0xc3, 0x5d, 0x9d, 0xcf, 0x3a, 0x97, 0x26, 0x4e, 0x58, 0x89, 0x73, 0xa4,
	0xbc, 0x0b, 0x9c, 0x20, 0x37, 0x43, 0xbd, 0xa1, 0xbb, 0x7a, 0x6a, 0x01, 0x61, 0x73, 0x91, 0x39,
	0x33, 0x59, 0xc7, 0x03, 0xad, 0xf8, 0x27, 0x86, 0x6d, 0xea, 0x2e, 0x73, 0x44, 0x83, 0x59, 0xa7,
	0xa6, 0xe1, 0xb8, 0xe4, 0x36, 0x3a, 0x3e, 0x9e, 0x82, 0x67, 0xc7, 0x86, 0xcb, 0x9c, 0xb6, 0x5e,
	0x67, 0xc9, 0x58, 0xcc, 0xaa, 0xdb, 0x1d, 0xcb, 0x65, 0x9c, 0x35, 0x08, 0x2f, 0xba, 0xd7, 0x0f,
	0x8e, 0x6d, 0x29, 0x0c, 0xf9, 0x93, 0x74, 0xd3, 0xfc, 0x28, 0x4a, 0x5f, 0xdc, 0x90, 0xc7, 0x20,
	0x27, 0xa2, 0x9d, 0x36, 0xe9, 0x21, 0x7c, 0x92, 0x6b, 0xdb, 0xe6, 0x76, 0x9b, 0x71, 0x37, 0x0b,
	0x19, 0xa2, 0xc9, 0xed, 0x56, 0xd1, 0x6f, 0xab, 0xb8, 0xba, 0x74, 0xc2, 0x0c, 0xad, 0x5c, 0xd5,
	0xb0, 0x8a, 0xc8, 0x6d, 0xba, 0x0d, 0x1b, 0xe9, 0x30, 0x1d, 0x6e, 0x92, 0x0f, 0x90, 0x90, 0x8a,
	0x22, 0xe1, 0x6e, 0x31, 0x0a, 0x76, 0xb8, 0x89, 0xe3, 0xb9, 0x76, 0xdd, 0x36, 0xc9, 0x87, 0xf4,
	0x1a, 0xec, 0x14, 0x0e, 0x54, 0xc3, 0x6e, 0xe9, 0x86, 0x45, 0xbe, 0x43, 0x83, 0x15, 0xc8, 0x9c,
	0x99, 0xba, 0x6b, 0x9c, 0x30, 0x39, 0xda, 0x17, 0xf4, 0x43, 0x78, 0xbf, 0xc0, 0xcc, 0x94, 0x9b,
	0x56, 0x8b, 0xe0, 0x09, 0x68, 0x75, 0xdc, 0x8e, 0x6e, 0x9a, 0xa7, 0x2a, 0x10, 0x3a, 0x38, 0x04,
	0x42, 0x1c, 0xb2, 0x83, 0x56, 0xef, 0x58, 0xcc, 0xa9, 0xeb, 0x6d, 0xb4, 0x50, 0xf6, 0x9b, 0x8c,
	0xa9, 0x31, 0x28, 0xd5, 0xe0, 0x76, 0xc6, 0x6b, 0xeb, 0xdc, 0x35, 0x74, 0xb3, 0x84, 0xd9, 0x45,
	0xef, 0x99, 0x91, 0xb7, 0xf4, 0x16, 0x23, 0x7b, 0xf4, 0x01, 0xdc, 0x43, 0x37, 0xb0, 0x1c, 0xc3,
	0x71, 0xd1, 0x63, 0x3b, 0x96, 0xe1, 0x3a, 0xa2, 0x69, 0x73, 0xf1, 0xcc, 0x68, 0xb8, 0xc7, 0xd2,
	0x29, 0x93, 0x47, 0xb2, 0x6b, 0xa5, 0x35, 0xa3, 0xeb, 0xeb, 0x56, 0x9d, 0x39, 0xae, 0xcd, 0xc9,
	0xbb, 0x72, 0x31, 0xd9, 0xee, 0x99, 0xba, 0xe3, 0x8a, 0xfa, 0xb1, 0x61, 0xaa, 0xbd, 0x3d, 0x9d,
	0x3e, 0xce, 0x53, 0x92, 0x77, 0x70, 0xa1, 0xf3, 0x79, 0xe2, 0x99, 0xe1, 0x1e, 0x8b, 0x63, 0xc3,
	0x72, 0xc9, 0x01, 0xda, 0x54, 0x2a, 0x5e, 0xd0, 0xe0, 0xe8, 0x54, 0x4c, 0x47, 0x17, 0xf2, 0x3e,
	0xbd, 0x07, 0x1f, 0xcc, 0x81, 0x95, 0x03, 0x0d, 0xd1, 0x50, 0xdf, 0x3c, 0x9a, 0x5b, 0x9d, 0x56,
	0xae, 0xae, 0x43, 0xbe, 0xc1, 0xb3, 0x9e, 0x73, 0x5b, 0x86, 0x55, 0x46, 0x74, 0x30, 0xf2, 0x15,
	0xe6, 0xc8, 0x58, 0xca, 0xb0, 0xbf, 0xc6, 0x24, 0x58, 0x60, 0x37, 0x0d, 0x5e, 0x34, 0x88, 0x02,
	0x3d, 0x92, 0x11, 0x25, 0x07, 0xb5, 0x74, 0xab, 0xd3, 0xd4, 0xeb, 0x6e, 0x47, 0x06, 0x59, 0xbb,
	0x71, 0x4a, 0x7e, 0x87, 0x67, 0x22, 0x97, 0x6a, 0xd8, 0xcc, 0x11, 0xb2, 0xa9, 0xa2, 0xbb, 0x86,
	0xd3, 0x3c, 0x15, 0x9c, 0x35, 0x19, 0x67, 0x56, 0x9d, 0x89, 0xb6, 0x8d, 0x56, 0x3a, 0x42, 0x2b,
	0xe5, 0xb6, 0x2c, 0xb1, 0xb3, 0xe8, 0x57, 0x97, 0xca, 0x67, 0xa1, 0xac, 0x3c, 0x4a, 0x03, 0x77,
	0x44, 0x6a, 0x69, 0xbb, 0x22, 0xdb, 0x6d, 0x5b, 0x1c, 0xeb, 0x27, 0x4c, 0x38, 0xc6, 0x91, 0x69,
	0x58, 0x8f, 0x1d, 0xf2, 0x0c, 0xb5, 0x57, 0xf9, 0x7d, 0x7a, 0x96, 0xba, 0x6d, 0x35, 0x4d, 0xa3,
	0xee, 0x12, 0x46, 0xbf, 0x86, 0x5f, 0xbe, 0xbd, 0xf6, 0x02, 0x75, 0xeb, 0x98, 0x3a, 0x27, 0x4d,
	0xf4, 0xea, 0x23, 0x4c, 0xab, 0xb2, 0xea, 0xe8, 0x38, 0xae, 0xc0, 0x50, 0xc1, 0x30, 0x7c, 0x98,
	0x26, 0x9e, 0x31, 0x87, 0x58, 0xf4, 0x36, 0xdc, 0x48, 0x0f, 0x75, 0x96, 0x9a, 0xb2, 0xec, 0x4f,
	0x1c, 0xdc, 0x81, 0x62, 0xcc, 0x9f, 0x07, 0xf2, 0x64, 0xb4, 0xb7, 0xeb, 0x9d, 0x96, 0x8c, 0xd6,
	0xb6, 0x2d, 0xea, 0x76, 0xab, 0x6d, 0xb2, 0xe7, 0xe4, 0x04, 0x2b, 0xa5, 0x2c, 0x22, 0xb8, 0xcd,
	0x6f, 0xc8, 0x5f, 0xc9, 0xdd, 0x4a, 0xb1, 0x8e, 0xf1, 0x7b, 0x26, 0x4c, 0xa3, 0x65, 0xb8, 0x78,
	0x72, 0x19, 0x6b, 0xb0, 0x06, 0xe9, 0xd3, 0x1d, 0xd8, 0x6a, 0xb0, 0x13, 0xd1, 0xb2, 0x1b, 0x4c,
	0xd8, 0x96, 0x79, 0x4a, 0x06, 0xd2, 0x6d, 0x5b, 0x6d, 0x21, 0x1f, 0x6a, 0x32, 0x55, 0x1c, 0x97,
	0x1b, 0x75, 0x57, 0xd4, 0x1d, 0x47, 0xc5, 0xc3, 0x57, 0x18, 0x3c, 0x55, 0xe8, 0x72, 0x98, 0xdc,
	0xa7, 0x96, 0xfc, 0xd9, 0xd3, 0x10, 0x17, 0x89, 0x28, 0xe7, 0xd4, 0x72, 0xf5, 0xe7, 0x22, 0x4f,
	0xdf, 0x82, 0x77, 0x4c, 0x46, 0xde, 0x43, 0x77, 0x2f, 0xf0, 0x1d, 0x97, 0xeb, 0xa7, 0xc2, 0xe5,
	0xba, 0x81, 0x7b, 0x24, 0x8e, 0xf4, 0xfa, 0x13, 0xc7, 0xd4, 0x9d, 0x63, 0xf2, 0x11, 0x5a, 0xa3,
	0x00, 0x94, 0x51, 0xbb, 0x65, 0x58, 0x32, 0xfa, 0xd6, 0xed, 0x96, 0x7c, 0xfa, 0xba, 0x87, 0x66,
	0xbf, 0x0a, 0x84, 0x2a, 0x5b, 0x8f, 0xc9, 0x7d, 0xd4, 0xb4, 0x80, 0x39, 0xd2, 0x55, 0x04, 0xfd,
	0x98, 0x7e, 0x06, 0x0f, 0x0a, 0x74, 0xcc, 0xc9, 0x86, 0x85, 0xdb, 0x86, 0xe5, 0x9d, 0xb0, 0x9b,
	0xe2, 0x69, 0x47, 0x37, 0xd5, 0x11, 0x94, 0xaa, 0x7f, 0x52, 0x9a, 0x2c, 0xab, 0x41, 0x59, 0xdd,
	0xd4, 0xb9, 0xee, 0xe2, 0xf6, 0x3c, 0x40, 0xeb, 0x4d, 0x61, 0xd4, 0xf6, 0x60, 0xc6, 0x2e, 0xc0,
	0x7e, 0x51, 0xb2, 0x82, 0xac, 0x80, 0xe5, 0xec, 0x0e, 0xeb, 0x34, 0x6c, 0xe1, 0x30, 0x93, 0xd5,
	0x31, 0xd4, 0x7c, 0x4a, 0xef, 0xc0, 0xcd, 0x02, 0x30, 0xdb, 0x8e, 0x14, 0x70, 0x58, 0x32, 0x93,
	0x3c, 0x00, 0x19, 0x5b, 0x38, 0xae, 0xce, 0x5d, 0xf2, 0x19, 0xfd, 0x02, 0x3e, 0x9d, 0x32, 0x53,
	0x5b, 0xe7, 0x0e, 0xc3, 0xe4, 0xdd, 0xee, 0x60, 0x45, 0x88, 0x19, 0xc2, 0xc1, 0xf9, 0xb3, 0x71,
	0x3f, 0xc7, 0xf8, 0x37, 0x67, 0x62, 0xb4, 0xdc, 0x97, 0x25, 0x5e, 0x31, 0x2f, 0xfd, 0xaa, 0xa4,
	0xcf, 0xdc, 0x14, 0xf5, 0x15, 0x3a, 0x66, 0x01, 0x34, 0x9b, 0xad, 0xbe, 0xa7, 0x1f, 0x81, 0x36,
	0x1f, 0x31, 0x95, 0xb8, 0xbe, 0xc6, 0x83, 0x3f, 0xd7, 0xdd, 0x5c, 0x9e, 0x2f, 0xe6, 0x37, 0x25,
	0x2b, 0x96, 0x73, 0x30, 0xf9, 0x7d, 0x69, 0xba, 0x99, 0x24, 0x6d, 0xd9, 0xb2, 0xb0, 0x10, 0x25,
	0x43, 0x4e, 0x7b, 0x88, 0x38, 0xd6, 0x31, 0x5c, 0x14, 0x77, 0xda, 0x21, 0x7f, 0x41, 0x7f, 0x07,
	0xdf, 0xce, 0x5f, 0x49, 0x49, 0x5a, 0x46, 0x8d, 0x23, 0xcc, 0x77, 0x8e, 0xd1, 0x60, 0xe2, 0x09,
	0x3b, 0x6d, 0x72, 0x0c, 0xba, 0x7f, 0x49, 0x1f, 0xc2, 0xe1, 0xfc, 0x11, 0x52, 0xcc, 0x8c, 0xcc,
	0x1f, 0x4a, 0x76, 0x69, 0xe9, 0x66, 0xd3, 0xe6, 0x2d, 0x0c, 0xd9, 0xac, 0x61, 0xe8, 0xe2, 0x69,
	0x87, 0xf1, 0x53, 0xf2, 0xa2, 0x84, 0x2a, 0x46, 0x76, 0x09, 0xc3, 0xbb, 0x15, 0xe9, 0x96, 0x9c,
	0x75, 0x06, 0xd5, 0x64, 0x3a, 0x66, 0x00, 0xd2, 0xbb, 0x1a, 0x38, 0xbd, 0x1f, 0xe1, 0xd5, 0xbb,
	0x9b, 0x1c, 0x80, 0xba, 0xa9, 0x3b, 0x0e, 0x89, 0xb0, 0x60, 0x7a, 0x2d, 0x2e, 0x7d, 0x03, 0x8f,
	0x5f, 0x83, 0x9c, 0x2a, 0xb4, 0xc8, 0xe3, 0x92, 0x83, 0x16, 0x90, 0x46, 0xab, 0x6d, 0x73, 0x57,
	0xb7, 0x5c, 0x32, 0x49, 0x3d, 0x1c, 0x23, 0xa5, 0x83, 0x35, 0x8e, 0x79, 0x2a, 0x2c, 0xe6, 0xb8,
	0xac, 0x41, 0x7e, 0xbc, 0x7a, 0x3b, 0x4a, 0x35, 0x5d, 0x5e, 0x0b, 0x1c, 0x97, 0xfc, 0x26, 0x03,
	0x16, 0x84, 0x11, 0x2d, 0x4b, 0x1d, 0x15, 0x6d, 0x0c, 0xfa, 0x39, 0xfc, 0xe2, 0x0d, 0x22, 0xae,
	0xfd, 0x98, 0xb9, 0xc7, 0x4c, 0x55, 0x1d, 0xe4, 0x07, 0x99, 0x7a, 0xe7, 0x48, 0x24, 0x69, 0xc4,
	0x49, 0x1d, 0xae, 0xae, 0x82, 0xd0, 0x13, 0x6d, 0x00, 0xa4, 0xdc, 0x4d, 0xfa, 0xf3, 0x3b, 0x18,
	0x07, 0xb0, 0x51, 0x6c, 0x5e, 0xc9, 0x46, 0x06, 0x2f, 0x92, 0xb4, 0x3f, 0xc2, 0x46, 0xa1, 0x03,
	0xf6, 0xe7, 0xcf, 0xb4, 0x0f, 0xab, 0xc9, 0xdb, 0x83, 0x7a, 0x7d, 0x4f, 0xbe, 0xb4, 0x3f, 0xc0,
	0x4e, 0xfa, 0x53, 0xe1, 0x76, 0x38, 0x4a, 0xda, 0x82, 0x0f, 0x61, 0x29, 0xf2, 0xe3, 0x64, 0x92,
	0x37, 0xff, 0xf2, 0x1c, 0xc1, 0xf9, 0x7f, 0x2c, 0x58, 0x2c, 0xfc, 0x7f, 0x16, 0xed, 0x1f, 0x17,
	0x60, 0x37, 0xc3, 0x15, 0x7e, 0x39, 0xf1, 0x1d, 0xac, 0x8f, 0xd3, 0xe9, 0xe4, 0x3c, 0xb3, 0x3d,
	0xb6, 0x19, 0xb5, 0x78, 0x2e, 0x42, 0xdb, 0xb0, 0xa7, 0x7a, 0x7f, 0xc1, 0x99, 0x98, 0x0c, 0xd3,
	0x67, 0xd6, 0x9e, 0x9c, 0x7c, 0xb6, 0x11, 0x56, 0xb2, 0x0b, 0xa7, 0x52, 0xd6, 0x38, 0xeb, 0xe4,
	0x92, 0xda, 0x3f, 0x2c, 0x03, 0xc9, 0x71, 0xdc, 0x8f, 0x26, 0x7d, 0x54, 0x73, 0x35, 0x8a, 0xbd,
	0x78, 0x12, 0xc9, 0x81, 0xab, 0x0f, 0x3f, 0xba, 0x72, 0x60, 0x25, 0x70, 0xe8, 0x48, 0x34, 0x4f,
	0xa4, 0xe8, 0x57, 0xb0, 0x2a, 0xa7, 0x4a, 0xdb, 0xc7, 0x6f, 0x52, 0x2c, 0x41, 0xd3, 0x2f, 0xb2,
	0x9f, 0x7c, 0x16, 0x9a, 0xc1, 0xaa, 0xa3, 0x25, 0x3b, 0xb9, 0x3b, 0x17, 0xe5, 0x26, 0xf0, 0x15,
	0xcd, 0xdf, 0xe5, 0xd7, 0x34, 0x7f, 0x1f, 0xc2, 0x6e, 0x1c, 0x7a, 0xc3, 0x08, 0x3d, 0xc1, 0x0f,
	0xb3, 0xdf, 0x1c, 0xa9, 0x7e, 0xf1, 0xc2, 0xe7, 0x9c, 0x16, 0xb8, 0xe9, 0xef, 0x8e, 0xee, 0xc1,
	0x76, 0x7c, 0x39, 0xf6, 0x45, 0xd0, 0xf3, 0x87, 0x71, 0x70, 0x16, 0xf8, 0x61, 0x6d, 0x45, 0xf6,
	0xcd, 0xaa, 0x48, 0x36, 0x32, 0x2a, 0xe5, 0xb0, 0xa7, 0xfe, 0xe7, 0x40, 0xe4, 0xc7, 0x22, 0xdb,
	0xb7, 0xb4, 0x29, 0xfe, 0xe6, 0xbd, 0xa6, 0x17, 0x65, 0x52, 0x44, 0x9f, 0xc3, 0x7e, 0x3e, 0x66,
	0x98, 0x7b, 0x93, 0x7a, 0x66, 0xde, 0x78, 0xa8, 0x5d, 0x31, 0x6a, 0xc1, 0xf1, 0xf8, 0xde, 0xc5,
	0x2c, 0x31, 0xd2, 0x3e, 0x86, 0x55, 0xb5, 0x73, 0xd3, 0xbf, 0x1b, 0xaa, 0xc0, 0x72, 0x1b, 0x63,
	0xea, 0x82, 0xfc, 0x7d, 0xa1, 0x6e, 0x98, 0x64, 0xf1, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xcf,
	0xb9, 0x00, 0xa8, 0x81, 0x36, 0x00, 0x00,
}