// Code generated by protoc-gen-go. DO NOT EDIT.
// source: envoy/config/filter/accesslog/v2/accesslog.proto

package envoy_config_filter_accesslog_v2

import (
	fmt "fmt"
	_ "github.com/cncf/udpa/go/udpa/annotations"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v2/core"
	route "github.com/envoyproxy/go-control-plane/envoy/api/v2/route"
	_type "github.com/envoyproxy/go-control-plane/envoy/type"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/golang/protobuf/proto"
	any "github.com/golang/protobuf/ptypes/any"
	_struct "github.com/golang/protobuf/ptypes/struct"
	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.ProtoPackageIsVersion3 // please upgrade the proto package

type ComparisonFilter_Op int32

const (
	ComparisonFilter_EQ ComparisonFilter_Op = 0
	ComparisonFilter_GE ComparisonFilter_Op = 1
	ComparisonFilter_LE ComparisonFilter_Op = 2
)

var ComparisonFilter_Op_name = map[int32]string{
	0: "EQ",
	1: "GE",
	2: "LE",
}

var ComparisonFilter_Op_value = map[string]int32{
	"EQ": 0,
	"GE": 1,
	"LE": 2,
}

func (x ComparisonFilter_Op) String() string {
	return proto.EnumName(ComparisonFilter_Op_name, int32(x))
}

func (ComparisonFilter_Op) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_67bfd82f8b509e9f, []int{2, 0}
}

type GrpcStatusFilter_Status int32

const (
	GrpcStatusFilter_OK                  GrpcStatusFilter_Status = 0
	GrpcStatusFilter_CANCELED            GrpcStatusFilter_Status = 1
	GrpcStatusFilter_UNKNOWN             GrpcStatusFilter_Status = 2
	GrpcStatusFilter_INVALID_ARGUMENT    GrpcStatusFilter_Status = 3
	GrpcStatusFilter_DEADLINE_EXCEEDED   GrpcStatusFilter_Status = 4
	GrpcStatusFilter_NOT_FOUND           GrpcStatusFilter_Status = 5
	GrpcStatusFilter_ALREADY_EXISTS      GrpcStatusFilter_Status = 6
	GrpcStatusFilter_PERMISSION_DENIED   GrpcStatusFilter_Status = 7
	GrpcStatusFilter_RESOURCE_EXHAUSTED  GrpcStatusFilter_Status = 8
	GrpcStatusFilter_FAILED_PRECONDITION GrpcStatusFilter_Status = 9
	GrpcStatusFilter_ABORTED             GrpcStatusFilter_Status = 10
	GrpcStatusFilter_OUT_OF_RANGE        GrpcStatusFilter_Status = 11
	GrpcStatusFilter_UNIMPLEMENTED       GrpcStatusFilter_Status = 12
	GrpcStatusFilter_INTERNAL            GrpcStatusFilter_Status = 13
	GrpcStatusFilter_UNAVAILABLE         GrpcStatusFilter_Status = 14
	GrpcStatusFilter_DATA_LOSS           GrpcStatusFilter_Status = 15
	GrpcStatusFilter_UNAUTHENTICATED     GrpcStatusFilter_Status = 16
)

var GrpcStatusFilter_Status_name = map[int32]string{
	0:  "OK",
	1:  "CANCELED",
	2:  "UNKNOWN",
	3:  "INVALID_ARGUMENT",
	4:  "DEADLINE_EXCEEDED",
	5:  "NOT_FOUND",
	6:  "ALREADY_EXISTS",
	7:  "PERMISSION_DENIED",
	8:  "RESOURCE_EXHAUSTED",
	9:  "FAILED_PRECONDITION",
	10: "ABORTED",
	11: "OUT_OF_RANGE",
	12: "UNIMPLEMENTED",
	13: "INTERNAL",
	14: "UNAVAILABLE",
	15: "DATA_LOSS",
	16: "UNAUTHENTICATED",
}

var GrpcStatusFilter_Status_value = map[string]int32{
	"OK":                  0,
	"CANCELED":            1,
	"UNKNOWN":             2,
	"INVALID_ARGUMENT":    3,
	"DEADLINE_EXCEEDED":   4,
	"NOT_FOUND":           5,
	"ALREADY_EXISTS":      6,
	"PERMISSION_DENIED":   7,
	"RESOURCE_EXHAUSTED":  8,
	"FAILED_PRECONDITION": 9,
	"ABORTED":             10,
	"OUT_OF_RANGE":        11,
	"UNIMPLEMENTED":       12,
	"INTERNAL":            13,
	"UNAVAILABLE":         14,
	"DATA_LOSS":           15,
	"UNAUTHENTICATED":     16,
}

func (x GrpcStatusFilter_Status) String() string {
	return proto.EnumName(GrpcStatusFilter_Status_name, int32(x))
}

func (GrpcStatusFilter_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_67bfd82f8b509e9f, []int{12, 0}
}

type AccessLog struct {
	Name   string           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Filter *AccessLogFilter `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
	// Types that are valid to be assigned to ConfigType:
	//	*AccessLog_Config
	//	*AccessLog_TypedConfig
	ConfigType           isAccessLog_ConfigType `protobuf_oneof:"config_type"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_AccessLog proto.InternalMessageInfo

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

func (m *AccessLog) GetFilter() *AccessLogFilter {
	if m != nil {
		return m.Filter
	}
	return nil
}

type isAccessLog_ConfigType interface {
	isAccessLog_ConfigType()
}

type AccessLog_Config struct {
	Config *_struct.Struct `protobuf:"bytes,3,opt,name=config,proto3,oneof"`
}

type AccessLog_TypedConfig struct {
	TypedConfig *any.Any `protobuf:"bytes,4,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

func (*AccessLog_Config) isAccessLog_ConfigType() {}

func (*AccessLog_TypedConfig) isAccessLog_ConfigType() {}

func (m *AccessLog) GetConfigType() isAccessLog_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

// Deprecated: Do not use.
func (m *AccessLog) GetConfig() *_struct.Struct {
	if x, ok := m.GetConfigType().(*AccessLog_Config); ok {
		return x.Config
	}
	return nil
}

func (m *AccessLog) GetTypedConfig() *any.Any {
	if x, ok := m.GetConfigType().(*AccessLog_TypedConfig); ok {
		return x.TypedConfig
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AccessLog) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*AccessLog_Config)(nil),
		(*AccessLog_TypedConfig)(nil),
	}
}

type AccessLogFilter struct {
	// Types that are valid to be assigned to FilterSpecifier:
	//	*AccessLogFilter_StatusCodeFilter
	//	*AccessLogFilter_DurationFilter
	//	*AccessLogFilter_NotHealthCheckFilter
	//	*AccessLogFilter_TraceableFilter
	//	*AccessLogFilter_RuntimeFilter
	//	*AccessLogFilter_AndFilter
	//	*AccessLogFilter_OrFilter
	//	*AccessLogFilter_HeaderFilter
	//	*AccessLogFilter_ResponseFlagFilter
	//	*AccessLogFilter_GrpcStatusFilter
	//	*AccessLogFilter_ExtensionFilter
	FilterSpecifier      isAccessLogFilter_FilterSpecifier `protobuf_oneof:"filter_specifier"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

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

var xxx_messageInfo_AccessLogFilter proto.InternalMessageInfo

type isAccessLogFilter_FilterSpecifier interface {
	isAccessLogFilter_FilterSpecifier()
}

type AccessLogFilter_StatusCodeFilter struct {
	StatusCodeFilter *StatusCodeFilter `protobuf:"bytes,1,opt,name=status_code_filter,json=statusCodeFilter,proto3,oneof"`
}

type AccessLogFilter_DurationFilter struct {
	DurationFilter *DurationFilter `protobuf:"bytes,2,opt,name=duration_filter,json=durationFilter,proto3,oneof"`
}

type AccessLogFilter_NotHealthCheckFilter struct {
	NotHealthCheckFilter *NotHealthCheckFilter `protobuf:"bytes,3,opt,name=not_health_check_filter,json=notHealthCheckFilter,proto3,oneof"`
}

type AccessLogFilter_TraceableFilter struct {
	TraceableFilter *TraceableFilter `protobuf:"bytes,4,opt,name=traceable_filter,json=traceableFilter,proto3,oneof"`
}

type AccessLogFilter_RuntimeFilter struct {
	RuntimeFilter *RuntimeFilter `protobuf:"bytes,5,opt,name=runtime_filter,json=runtimeFilter,proto3,oneof"`
}

type AccessLogFilter_AndFilter struct {
	AndFilter *AndFilter `protobuf:"bytes,6,opt,name=and_filter,json=andFilter,proto3,oneof"`
}

type AccessLogFilter_OrFilter struct {
	OrFilter *OrFilter `protobuf:"bytes,7,opt,name=or_filter,json=orFilter,proto3,oneof"`
}

type AccessLogFilter_HeaderFilter struct {
	HeaderFilter *HeaderFilter `protobuf:"bytes,8,opt,name=header_filter,json=headerFilter,proto3,oneof"`
}

type AccessLogFilter_ResponseFlagFilter struct {
	ResponseFlagFilter *ResponseFlagFilter `protobuf:"bytes,9,opt,name=response_flag_filter,json=responseFlagFilter,proto3,oneof"`
}

type AccessLogFilter_GrpcStatusFilter struct {
	GrpcStatusFilter *GrpcStatusFilter `protobuf:"bytes,10,opt,name=grpc_status_filter,json=grpcStatusFilter,proto3,oneof"`
}

type AccessLogFilter_ExtensionFilter struct {
	ExtensionFilter *ExtensionFilter `protobuf:"bytes,11,opt,name=extension_filter,json=extensionFilter,proto3,oneof"`
}

func (*AccessLogFilter_StatusCodeFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_DurationFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_NotHealthCheckFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_TraceableFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_RuntimeFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_AndFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_OrFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_HeaderFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_ResponseFlagFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_GrpcStatusFilter) isAccessLogFilter_FilterSpecifier() {}

func (*AccessLogFilter_ExtensionFilter) isAccessLogFilter_FilterSpecifier() {}

func (m *AccessLogFilter) GetFilterSpecifier() isAccessLogFilter_FilterSpecifier {
	if m != nil {
		return m.FilterSpecifier
	}
	return nil
}

func (m *AccessLogFilter) GetStatusCodeFilter() *StatusCodeFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_StatusCodeFilter); ok {
		return x.StatusCodeFilter
	}
	return nil
}

func (m *AccessLogFilter) GetDurationFilter() *DurationFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_DurationFilter); ok {
		return x.DurationFilter
	}
	return nil
}

func (m *AccessLogFilter) GetNotHealthCheckFilter() *NotHealthCheckFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_NotHealthCheckFilter); ok {
		return x.NotHealthCheckFilter
	}
	return nil
}

func (m *AccessLogFilter) GetTraceableFilter() *TraceableFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_TraceableFilter); ok {
		return x.TraceableFilter
	}
	return nil
}

func (m *AccessLogFilter) GetRuntimeFilter() *RuntimeFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_RuntimeFilter); ok {
		return x.RuntimeFilter
	}
	return nil
}

func (m *AccessLogFilter) GetAndFilter() *AndFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_AndFilter); ok {
		return x.AndFilter
	}
	return nil
}

func (m *AccessLogFilter) GetOrFilter() *OrFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_OrFilter); ok {
		return x.OrFilter
	}
	return nil
}

func (m *AccessLogFilter) GetHeaderFilter() *HeaderFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_HeaderFilter); ok {
		return x.HeaderFilter
	}
	return nil
}

func (m *AccessLogFilter) GetResponseFlagFilter() *ResponseFlagFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_ResponseFlagFilter); ok {
		return x.ResponseFlagFilter
	}
	return nil
}

func (m *AccessLogFilter) GetGrpcStatusFilter() *GrpcStatusFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_GrpcStatusFilter); ok {
		return x.GrpcStatusFilter
	}
	return nil
}

func (m *AccessLogFilter) GetExtensionFilter() *ExtensionFilter {
	if x, ok := m.GetFilterSpecifier().(*AccessLogFilter_ExtensionFilter); ok {
		return x.ExtensionFilter
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AccessLogFilter) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*AccessLogFilter_StatusCodeFilter)(nil),
		(*AccessLogFilter_DurationFilter)(nil),
		(*AccessLogFilter_NotHealthCheckFilter)(nil),
		(*AccessLogFilter_TraceableFilter)(nil),
		(*AccessLogFilter_RuntimeFilter)(nil),
		(*AccessLogFilter_AndFilter)(nil),
		(*AccessLogFilter_OrFilter)(nil),
		(*AccessLogFilter_HeaderFilter)(nil),
		(*AccessLogFilter_ResponseFlagFilter)(nil),
		(*AccessLogFilter_GrpcStatusFilter)(nil),
		(*AccessLogFilter_ExtensionFilter)(nil),
	}
}

type ComparisonFilter struct {
	Op                   ComparisonFilter_Op `protobuf:"varint,1,opt,name=op,proto3,enum=envoy.config.filter.accesslog.v2.ComparisonFilter_Op" json:"op,omitempty"`
	Value                *core.RuntimeUInt32 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_ComparisonFilter proto.InternalMessageInfo

func (m *ComparisonFilter) GetOp() ComparisonFilter_Op {
	if m != nil {
		return m.Op
	}
	return ComparisonFilter_EQ
}

func (m *ComparisonFilter) GetValue() *core.RuntimeUInt32 {
	if m != nil {
		return m.Value
	}
	return nil
}

type StatusCodeFilter struct {
	Comparison           *ComparisonFilter `protobuf:"bytes,1,opt,name=comparison,proto3" json:"comparison,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_StatusCodeFilter proto.InternalMessageInfo

func (m *StatusCodeFilter) GetComparison() *ComparisonFilter {
	if m != nil {
		return m.Comparison
	}
	return nil
}

type DurationFilter struct {
	Comparison           *ComparisonFilter `protobuf:"bytes,1,opt,name=comparison,proto3" json:"comparison,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_DurationFilter proto.InternalMessageInfo

func (m *DurationFilter) GetComparison() *ComparisonFilter {
	if m != nil {
		return m.Comparison
	}
	return nil
}

type NotHealthCheckFilter struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NotHealthCheckFilter proto.InternalMessageInfo

type TraceableFilter struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TraceableFilter proto.InternalMessageInfo

type RuntimeFilter struct {
	RuntimeKey               string                   `protobuf:"bytes,1,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	PercentSampled           *_type.FractionalPercent `protobuf:"bytes,2,opt,name=percent_sampled,json=percentSampled,proto3" json:"percent_sampled,omitempty"`
	UseIndependentRandomness bool                     `protobuf:"varint,3,opt,name=use_independent_randomness,json=useIndependentRandomness,proto3" json:"use_independent_randomness,omitempty"`
	XXX_NoUnkeyedLiteral     struct{}                 `json:"-"`
	XXX_unrecognized         []byte                   `json:"-"`
	XXX_sizecache            int32                    `json:"-"`
}

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

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

var xxx_messageInfo_RuntimeFilter proto.InternalMessageInfo

func (m *RuntimeFilter) GetRuntimeKey() string {
	if m != nil {
		return m.RuntimeKey
	}
	return ""
}

func (m *RuntimeFilter) GetPercentSampled() *_type.FractionalPercent {
	if m != nil {
		return m.PercentSampled
	}
	return nil
}

func (m *RuntimeFilter) GetUseIndependentRandomness() bool {
	if m != nil {
		return m.UseIndependentRandomness
	}
	return false
}

type AndFilter struct {
	Filters              []*AccessLogFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_AndFilter proto.InternalMessageInfo

func (m *AndFilter) GetFilters() []*AccessLogFilter {
	if m != nil {
		return m.Filters
	}
	return nil
}

type OrFilter struct {
	Filters              []*AccessLogFilter `protobuf:"bytes,2,rep,name=filters,proto3" json:"filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_OrFilter proto.InternalMessageInfo

func (m *OrFilter) GetFilters() []*AccessLogFilter {
	if m != nil {
		return m.Filters
	}
	return nil
}

type HeaderFilter struct {
	Header               *route.HeaderMatcher `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_HeaderFilter proto.InternalMessageInfo

func (m *HeaderFilter) GetHeader() *route.HeaderMatcher {
	if m != nil {
		return m.Header
	}
	return nil
}

type ResponseFlagFilter struct {
	Flags                []string `protobuf:"bytes,1,rep,name=flags,proto3" json:"flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ResponseFlagFilter proto.InternalMessageInfo

func (m *ResponseFlagFilter) GetFlags() []string {
	if m != nil {
		return m.Flags
	}
	return nil
}

type GrpcStatusFilter struct {
	Statuses             []GrpcStatusFilter_Status `protobuf:"varint,1,rep,packed,name=statuses,proto3,enum=envoy.config.filter.accesslog.v2.GrpcStatusFilter_Status" json:"statuses,omitempty"`
	Exclude              bool                      `protobuf:"varint,2,opt,name=exclude,proto3" json:"exclude,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

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

var xxx_messageInfo_GrpcStatusFilter proto.InternalMessageInfo

func (m *GrpcStatusFilter) GetStatuses() []GrpcStatusFilter_Status {
	if m != nil {
		return m.Statuses
	}
	return nil
}

func (m *GrpcStatusFilter) GetExclude() bool {
	if m != nil {
		return m.Exclude
	}
	return false
}

type ExtensionFilter struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to ConfigType:
	//	*ExtensionFilter_Config
	//	*ExtensionFilter_TypedConfig
	ConfigType           isExtensionFilter_ConfigType `protobuf_oneof:"config_type"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

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

var xxx_messageInfo_ExtensionFilter proto.InternalMessageInfo

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

type isExtensionFilter_ConfigType interface {
	isExtensionFilter_ConfigType()
}

type ExtensionFilter_Config struct {
	Config *_struct.Struct `protobuf:"bytes,2,opt,name=config,proto3,oneof"`
}

type ExtensionFilter_TypedConfig struct {
	TypedConfig *any.Any `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3,oneof"`
}

func (*ExtensionFilter_Config) isExtensionFilter_ConfigType() {}

func (*ExtensionFilter_TypedConfig) isExtensionFilter_ConfigType() {}

func (m *ExtensionFilter) GetConfigType() isExtensionFilter_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

// Deprecated: Do not use.
func (m *ExtensionFilter) GetConfig() *_struct.Struct {
	if x, ok := m.GetConfigType().(*ExtensionFilter_Config); ok {
		return x.Config
	}
	return nil
}

func (m *ExtensionFilter) GetTypedConfig() *any.Any {
	if x, ok := m.GetConfigType().(*ExtensionFilter_TypedConfig); ok {
		return x.TypedConfig
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ExtensionFilter) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ExtensionFilter_Config)(nil),
		(*ExtensionFilter_TypedConfig)(nil),
	}
}

func init() {
	proto.RegisterEnum("envoy.config.filter.accesslog.v2.ComparisonFilter_Op", ComparisonFilter_Op_name, ComparisonFilter_Op_value)
	proto.RegisterEnum("envoy.config.filter.accesslog.v2.GrpcStatusFilter_Status", GrpcStatusFilter_Status_name, GrpcStatusFilter_Status_value)
	proto.RegisterType((*AccessLog)(nil), "envoy.config.filter.accesslog.v2.AccessLog")
	proto.RegisterType((*AccessLogFilter)(nil), "envoy.config.filter.accesslog.v2.AccessLogFilter")
	proto.RegisterType((*ComparisonFilter)(nil), "envoy.config.filter.accesslog.v2.ComparisonFilter")
	proto.RegisterType((*StatusCodeFilter)(nil), "envoy.config.filter.accesslog.v2.StatusCodeFilter")
	proto.RegisterType((*DurationFilter)(nil), "envoy.config.filter.accesslog.v2.DurationFilter")
	proto.RegisterType((*NotHealthCheckFilter)(nil), "envoy.config.filter.accesslog.v2.NotHealthCheckFilter")
	proto.RegisterType((*TraceableFilter)(nil), "envoy.config.filter.accesslog.v2.TraceableFilter")
	proto.RegisterType((*RuntimeFilter)(nil), "envoy.config.filter.accesslog.v2.RuntimeFilter")
	proto.RegisterType((*AndFilter)(nil), "envoy.config.filter.accesslog.v2.AndFilter")
	proto.RegisterType((*OrFilter)(nil), "envoy.config.filter.accesslog.v2.OrFilter")
	proto.RegisterType((*HeaderFilter)(nil), "envoy.config.filter.accesslog.v2.HeaderFilter")
	proto.RegisterType((*ResponseFlagFilter)(nil), "envoy.config.filter.accesslog.v2.ResponseFlagFilter")
	proto.RegisterType((*GrpcStatusFilter)(nil), "envoy.config.filter.accesslog.v2.GrpcStatusFilter")
	proto.RegisterType((*ExtensionFilter)(nil), "envoy.config.filter.accesslog.v2.ExtensionFilter")
}

func init() {
	proto.RegisterFile("envoy/config/filter/accesslog/v2/accesslog.proto", fileDescriptor_67bfd82f8b509e9f)
}

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