// Code generated by protoc-gen-go. DO NOT EDIT.
// source: envoy/api/v2/core/base.proto

package envoy_api_v2_core

import (
	fmt "fmt"
	_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"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	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 RoutingPriority int32

const (
	RoutingPriority_DEFAULT RoutingPriority = 0
	RoutingPriority_HIGH    RoutingPriority = 1
)

var RoutingPriority_name = map[int32]string{
	0: "DEFAULT",
	1: "HIGH",
}

var RoutingPriority_value = map[string]int32{
	"DEFAULT": 0,
	"HIGH":    1,
}

func (x RoutingPriority) String() string {
	return proto.EnumName(RoutingPriority_name, int32(x))
}

func (RoutingPriority) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a7738c0f9e1bfff4, []int{0}
}

type RequestMethod int32

const (
	RequestMethod_METHOD_UNSPECIFIED RequestMethod = 0
	RequestMethod_GET                RequestMethod = 1
	RequestMethod_HEAD               RequestMethod = 2
	RequestMethod_POST               RequestMethod = 3
	RequestMethod_PUT                RequestMethod = 4
	RequestMethod_DELETE             RequestMethod = 5
	RequestMethod_CONNECT            RequestMethod = 6
	RequestMethod_OPTIONS            RequestMethod = 7
	RequestMethod_TRACE              RequestMethod = 8
	RequestMethod_PATCH              RequestMethod = 9
)

var RequestMethod_name = map[int32]string{
	0: "METHOD_UNSPECIFIED",
	1: "GET",
	2: "HEAD",
	3: "POST",
	4: "PUT",
	5: "DELETE",
	6: "CONNECT",
	7: "OPTIONS",
	8: "TRACE",
	9: "PATCH",
}

var RequestMethod_value = map[string]int32{
	"METHOD_UNSPECIFIED": 0,
	"GET":                1,
	"HEAD":               2,
	"POST":               3,
	"PUT":                4,
	"DELETE":             5,
	"CONNECT":            6,
	"OPTIONS":            7,
	"TRACE":              8,
	"PATCH":              9,
}

func (x RequestMethod) String() string {
	return proto.EnumName(RequestMethod_name, int32(x))
}

func (RequestMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a7738c0f9e1bfff4, []int{1}
}

type TrafficDirection int32

const (
	TrafficDirection_UNSPECIFIED TrafficDirection = 0
	TrafficDirection_INBOUND     TrafficDirection = 1
	TrafficDirection_OUTBOUND    TrafficDirection = 2
)

var TrafficDirection_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "INBOUND",
	2: "OUTBOUND",
}

var TrafficDirection_value = map[string]int32{
	"UNSPECIFIED": 0,
	"INBOUND":     1,
	"OUTBOUND":    2,
}

func (x TrafficDirection) String() string {
	return proto.EnumName(TrafficDirection_name, int32(x))
}

func (TrafficDirection) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a7738c0f9e1bfff4, []int{2}
}

type SocketOption_SocketState int32

const (
	SocketOption_STATE_PREBIND   SocketOption_SocketState = 0
	SocketOption_STATE_BOUND     SocketOption_SocketState = 1
	SocketOption_STATE_LISTENING SocketOption_SocketState = 2
)

var SocketOption_SocketState_name = map[int32]string{
	0: "STATE_PREBIND",
	1: "STATE_BOUND",
	2: "STATE_LISTENING",
}

var SocketOption_SocketState_value = map[string]int32{
	"STATE_PREBIND":   0,
	"STATE_BOUND":     1,
	"STATE_LISTENING": 2,
}

func (x SocketOption_SocketState) String() string {
	return proto.EnumName(SocketOption_SocketState_name, int32(x))
}

func (SocketOption_SocketState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a7738c0f9e1bfff4, []int{12, 0}
}

type Locality struct {
	Region               string   `protobuf:"bytes,1,opt,name=region,proto3" json:"region,omitempty"`
	Zone                 string   `protobuf:"bytes,2,opt,name=zone,proto3" json:"zone,omitempty"`
	SubZone              string   `protobuf:"bytes,3,opt,name=sub_zone,json=subZone,proto3" json:"sub_zone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Locality proto.InternalMessageInfo

func (m *Locality) GetRegion() string {
	if m != nil {
		return m.Region
	}
	return ""
}

func (m *Locality) GetZone() string {
	if m != nil {
		return m.Zone
	}
	return ""
}

func (m *Locality) GetSubZone() string {
	if m != nil {
		return m.SubZone
	}
	return ""
}

type Node struct {
	Id                   string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Cluster              string          `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Metadata             *_struct.Struct `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Locality             *Locality       `protobuf:"bytes,4,opt,name=locality,proto3" json:"locality,omitempty"`
	BuildVersion         string          `protobuf:"bytes,5,opt,name=build_version,json=buildVersion,proto3" json:"build_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Node) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

func (m *Node) GetMetadata() *_struct.Struct {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Node) GetLocality() *Locality {
	if m != nil {
		return m.Locality
	}
	return nil
}

func (m *Node) GetBuildVersion() string {
	if m != nil {
		return m.BuildVersion
	}
	return ""
}

type Metadata struct {
	FilterMetadata       map[string]*_struct.Struct `protobuf:"bytes,1,rep,name=filter_metadata,json=filterMetadata,proto3" json:"filter_metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

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

var xxx_messageInfo_Metadata proto.InternalMessageInfo

func (m *Metadata) GetFilterMetadata() map[string]*_struct.Struct {
	if m != nil {
		return m.FilterMetadata
	}
	return nil
}

type RuntimeUInt32 struct {
	DefaultValue         uint32   `protobuf:"varint,2,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	RuntimeKey           string   `protobuf:"bytes,3,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RuntimeUInt32 proto.InternalMessageInfo

func (m *RuntimeUInt32) GetDefaultValue() uint32 {
	if m != nil {
		return m.DefaultValue
	}
	return 0
}

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

type RuntimeFeatureFlag struct {
	DefaultValue         *wrappers.BoolValue `protobuf:"bytes,1,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	RuntimeKey           string              `protobuf:"bytes,2,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_RuntimeFeatureFlag proto.InternalMessageInfo

func (m *RuntimeFeatureFlag) GetDefaultValue() *wrappers.BoolValue {
	if m != nil {
		return m.DefaultValue
	}
	return nil
}

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

type HeaderValue struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_HeaderValue proto.InternalMessageInfo

func (m *HeaderValue) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

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

type HeaderValueOption struct {
	Header               *HeaderValue        `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	Append               *wrappers.BoolValue `protobuf:"bytes,2,opt,name=append,proto3" json:"append,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_HeaderValueOption proto.InternalMessageInfo

func (m *HeaderValueOption) GetHeader() *HeaderValue {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *HeaderValueOption) GetAppend() *wrappers.BoolValue {
	if m != nil {
		return m.Append
	}
	return nil
}

type HeaderMap struct {
	Headers              []*HeaderValue `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_HeaderMap proto.InternalMessageInfo

func (m *HeaderMap) GetHeaders() []*HeaderValue {
	if m != nil {
		return m.Headers
	}
	return nil
}

type DataSource struct {
	// Types that are valid to be assigned to Specifier:
	//	*DataSource_Filename
	//	*DataSource_InlineBytes
	//	*DataSource_InlineString
	Specifier            isDataSource_Specifier `protobuf_oneof:"specifier"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_DataSource proto.InternalMessageInfo

type isDataSource_Specifier interface {
	isDataSource_Specifier()
}

type DataSource_Filename struct {
	Filename string `protobuf:"bytes,1,opt,name=filename,proto3,oneof"`
}

type DataSource_InlineBytes struct {
	InlineBytes []byte `protobuf:"bytes,2,opt,name=inline_bytes,json=inlineBytes,proto3,oneof"`
}

type DataSource_InlineString struct {
	InlineString string `protobuf:"bytes,3,opt,name=inline_string,json=inlineString,proto3,oneof"`
}

func (*DataSource_Filename) isDataSource_Specifier() {}

func (*DataSource_InlineBytes) isDataSource_Specifier() {}

func (*DataSource_InlineString) isDataSource_Specifier() {}

func (m *DataSource) GetSpecifier() isDataSource_Specifier {
	if m != nil {
		return m.Specifier
	}
	return nil
}

func (m *DataSource) GetFilename() string {
	if x, ok := m.GetSpecifier().(*DataSource_Filename); ok {
		return x.Filename
	}
	return ""
}

func (m *DataSource) GetInlineBytes() []byte {
	if x, ok := m.GetSpecifier().(*DataSource_InlineBytes); ok {
		return x.InlineBytes
	}
	return nil
}

func (m *DataSource) GetInlineString() string {
	if x, ok := m.GetSpecifier().(*DataSource_InlineString); ok {
		return x.InlineString
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*DataSource) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*DataSource_Filename)(nil),
		(*DataSource_InlineBytes)(nil),
		(*DataSource_InlineString)(nil),
	}
}

type RemoteDataSource struct {
	HttpUri              *HttpUri `protobuf:"bytes,1,opt,name=http_uri,json=httpUri,proto3" json:"http_uri,omitempty"`
	Sha256               string   `protobuf:"bytes,2,opt,name=sha256,proto3" json:"sha256,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RemoteDataSource proto.InternalMessageInfo

func (m *RemoteDataSource) GetHttpUri() *HttpUri {
	if m != nil {
		return m.HttpUri
	}
	return nil
}

func (m *RemoteDataSource) GetSha256() string {
	if m != nil {
		return m.Sha256
	}
	return ""
}

type AsyncDataSource struct {
	// Types that are valid to be assigned to Specifier:
	//	*AsyncDataSource_Local
	//	*AsyncDataSource_Remote
	Specifier            isAsyncDataSource_Specifier `protobuf_oneof:"specifier"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

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

var xxx_messageInfo_AsyncDataSource proto.InternalMessageInfo

type isAsyncDataSource_Specifier interface {
	isAsyncDataSource_Specifier()
}

type AsyncDataSource_Local struct {
	Local *DataSource `protobuf:"bytes,1,opt,name=local,proto3,oneof"`
}

type AsyncDataSource_Remote struct {
	Remote *RemoteDataSource `protobuf:"bytes,2,opt,name=remote,proto3,oneof"`
}

func (*AsyncDataSource_Local) isAsyncDataSource_Specifier() {}

func (*AsyncDataSource_Remote) isAsyncDataSource_Specifier() {}

func (m *AsyncDataSource) GetSpecifier() isAsyncDataSource_Specifier {
	if m != nil {
		return m.Specifier
	}
	return nil
}

func (m *AsyncDataSource) GetLocal() *DataSource {
	if x, ok := m.GetSpecifier().(*AsyncDataSource_Local); ok {
		return x.Local
	}
	return nil
}

func (m *AsyncDataSource) GetRemote() *RemoteDataSource {
	if x, ok := m.GetSpecifier().(*AsyncDataSource_Remote); ok {
		return x.Remote
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AsyncDataSource) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*AsyncDataSource_Local)(nil),
		(*AsyncDataSource_Remote)(nil),
	}
}

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

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

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

var xxx_messageInfo_TransportSocket proto.InternalMessageInfo

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

type isTransportSocket_ConfigType interface {
	isTransportSocket_ConfigType()
}

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

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

func (*TransportSocket_Config) isTransportSocket_ConfigType() {}

func (*TransportSocket_TypedConfig) isTransportSocket_ConfigType() {}

func (m *TransportSocket) GetConfigType() isTransportSocket_ConfigType {
	if m != nil {
		return m.ConfigType
	}
	return nil
}

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*TransportSocket) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*TransportSocket_Config)(nil),
		(*TransportSocket_TypedConfig)(nil),
	}
}

type SocketOption struct {
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
	Level       int64  `protobuf:"varint,2,opt,name=level,proto3" json:"level,omitempty"`
	Name        int64  `protobuf:"varint,3,opt,name=name,proto3" json:"name,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*SocketOption_IntValue
	//	*SocketOption_BufValue
	Value                isSocketOption_Value     `protobuf_oneof:"value"`
	State                SocketOption_SocketState `protobuf:"varint,6,opt,name=state,proto3,enum=envoy.api.v2.core.SocketOption_SocketState" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SocketOption proto.InternalMessageInfo

func (m *SocketOption) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *SocketOption) GetLevel() int64 {
	if m != nil {
		return m.Level
	}
	return 0
}

func (m *SocketOption) GetName() int64 {
	if m != nil {
		return m.Name
	}
	return 0
}

type isSocketOption_Value interface {
	isSocketOption_Value()
}

type SocketOption_IntValue struct {
	IntValue int64 `protobuf:"varint,4,opt,name=int_value,json=intValue,proto3,oneof"`
}

type SocketOption_BufValue struct {
	BufValue []byte `protobuf:"bytes,5,opt,name=buf_value,json=bufValue,proto3,oneof"`
}

func (*SocketOption_IntValue) isSocketOption_Value() {}

func (*SocketOption_BufValue) isSocketOption_Value() {}

func (m *SocketOption) GetValue() isSocketOption_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *SocketOption) GetIntValue() int64 {
	if x, ok := m.GetValue().(*SocketOption_IntValue); ok {
		return x.IntValue
	}
	return 0
}

func (m *SocketOption) GetBufValue() []byte {
	if x, ok := m.GetValue().(*SocketOption_BufValue); ok {
		return x.BufValue
	}
	return nil
}

func (m *SocketOption) GetState() SocketOption_SocketState {
	if m != nil {
		return m.State
	}
	return SocketOption_STATE_PREBIND
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SocketOption) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SocketOption_IntValue)(nil),
		(*SocketOption_BufValue)(nil),
	}
}

type RuntimeFractionalPercent struct {
	DefaultValue         *_type.FractionalPercent `protobuf:"bytes,1,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
	RuntimeKey           string                   `protobuf:"bytes,2,opt,name=runtime_key,json=runtimeKey,proto3" json:"runtime_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_RuntimeFractionalPercent proto.InternalMessageInfo

func (m *RuntimeFractionalPercent) GetDefaultValue() *_type.FractionalPercent {
	if m != nil {
		return m.DefaultValue
	}
	return nil
}

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

type ControlPlane struct {
	Identifier           string   `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ControlPlane proto.InternalMessageInfo

func (m *ControlPlane) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func init() {
	proto.RegisterEnum("envoy.api.v2.core.RoutingPriority", RoutingPriority_name, RoutingPriority_value)
	proto.RegisterEnum("envoy.api.v2.core.RequestMethod", RequestMethod_name, RequestMethod_value)
	proto.RegisterEnum("envoy.api.v2.core.TrafficDirection", TrafficDirection_name, TrafficDirection_value)
	proto.RegisterEnum("envoy.api.v2.core.SocketOption_SocketState", SocketOption_SocketState_name, SocketOption_SocketState_value)
	proto.RegisterType((*Locality)(nil), "envoy.api.v2.core.Locality")
	proto.RegisterType((*Node)(nil), "envoy.api.v2.core.Node")
	proto.RegisterType((*Metadata)(nil), "envoy.api.v2.core.Metadata")
	proto.RegisterMapType((map[string]*_struct.Struct)(nil), "envoy.api.v2.core.Metadata.FilterMetadataEntry")
	proto.RegisterType((*RuntimeUInt32)(nil), "envoy.api.v2.core.RuntimeUInt32")
	proto.RegisterType((*RuntimeFeatureFlag)(nil), "envoy.api.v2.core.RuntimeFeatureFlag")
	proto.RegisterType((*HeaderValue)(nil), "envoy.api.v2.core.HeaderValue")
	proto.RegisterType((*HeaderValueOption)(nil), "envoy.api.v2.core.HeaderValueOption")
	proto.RegisterType((*HeaderMap)(nil), "envoy.api.v2.core.HeaderMap")
	proto.RegisterType((*DataSource)(nil), "envoy.api.v2.core.DataSource")
	proto.RegisterType((*RemoteDataSource)(nil), "envoy.api.v2.core.RemoteDataSource")
	proto.RegisterType((*AsyncDataSource)(nil), "envoy.api.v2.core.AsyncDataSource")
	proto.RegisterType((*TransportSocket)(nil), "envoy.api.v2.core.TransportSocket")
	proto.RegisterType((*SocketOption)(nil), "envoy.api.v2.core.SocketOption")
	proto.RegisterType((*RuntimeFractionalPercent)(nil), "envoy.api.v2.core.RuntimeFractionalPercent")
	proto.RegisterType((*ControlPlane)(nil), "envoy.api.v2.core.ControlPlane")
}

func init() { proto.RegisterFile("envoy/api/v2/core/base.proto", fileDescriptor_a7738c0f9e1bfff4) }

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