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

package core

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import any "github.com/golang/protobuf/ptypes/any"
import _struct "github.com/golang/protobuf/ptypes/struct"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import percent "google.golang.org/grpc/balancer/xds/internal/proto/envoy/type/percent"
import _ "google.golang.org/grpc/balancer/xds/internal/proto/validate"

// 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

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_base_12218511885b7551, []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_base_12218511885b7551, []int{1}
}

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_base_12218511885b7551, []int{9, 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_base_12218511885b7551, []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 (dst *Locality) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Locality.Merge(dst, 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_base_12218511885b7551, []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 (dst *Node) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Node.Merge(dst, 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_base_12218511885b7551, []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 (dst *Metadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Metadata.Merge(dst, 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_base_12218511885b7551, []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 (dst *RuntimeUInt32) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeUInt32.Merge(dst, 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 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_base_12218511885b7551, []int{4}
}
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 (dst *HeaderValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderValue.Merge(dst, 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_base_12218511885b7551, []int{5}
}
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 (dst *HeaderValueOption) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderValueOption.Merge(dst, 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_base_12218511885b7551, []int{6}
}
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 (dst *HeaderMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeaderMap.Merge(dst, 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_base_12218511885b7551, []int{7}
}
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 (dst *DataSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DataSource.Merge(dst, 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_OneofFuncs is for the internal use of the proto package.
func (*DataSource) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _DataSource_OneofMarshaler, _DataSource_OneofUnmarshaler, _DataSource_OneofSizer, []interface{}{
		(*DataSource_Filename)(nil),
		(*DataSource_InlineBytes)(nil),
		(*DataSource_InlineString)(nil),
	}
}

func _DataSource_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*DataSource)
	// specifier
	switch x := m.Specifier.(type) {
	case *DataSource_Filename:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Filename)
	case *DataSource_InlineBytes:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeRawBytes(x.InlineBytes)
	case *DataSource_InlineString:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.InlineString)
	case nil:
	default:
		return fmt.Errorf("DataSource.Specifier has unexpected type %T", x)
	}
	return nil
}

func _DataSource_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*DataSource)
	switch tag {
	case 1: // specifier.filename
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Specifier = &DataSource_Filename{x}
		return true, err
	case 2: // specifier.inline_bytes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Specifier = &DataSource_InlineBytes{x}
		return true, err
	case 3: // specifier.inline_string
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Specifier = &DataSource_InlineString{x}
		return true, err
	default:
		return false, nil
	}
}

func _DataSource_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*DataSource)
	// specifier
	switch x := m.Specifier.(type) {
	case *DataSource_Filename:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Filename)))
		n += len(x.Filename)
	case *DataSource_InlineBytes:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.InlineBytes)))
		n += len(x.InlineBytes)
	case *DataSource_InlineString:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.InlineString)))
		n += len(x.InlineString)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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_base_12218511885b7551, []int{8}
}
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 (dst *TransportSocket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransportSocket.Merge(dst, 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
}

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_OneofFuncs is for the internal use of the proto package.
func (*TransportSocket) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _TransportSocket_OneofMarshaler, _TransportSocket_OneofUnmarshaler, _TransportSocket_OneofSizer, []interface{}{
		(*TransportSocket_Config)(nil),
		(*TransportSocket_TypedConfig)(nil),
	}
}

func _TransportSocket_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*TransportSocket)
	// config_type
	switch x := m.ConfigType.(type) {
	case *TransportSocket_Config:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Config); err != nil {
			return err
		}
	case *TransportSocket_TypedConfig:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TypedConfig); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("TransportSocket.ConfigType has unexpected type %T", x)
	}
	return nil
}

func _TransportSocket_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*TransportSocket)
	switch tag {
	case 2: // config_type.config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(_struct.Struct)
		err := b.DecodeMessage(msg)
		m.ConfigType = &TransportSocket_Config{msg}
		return true, err
	case 3: // config_type.typed_config
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(any.Any)
		err := b.DecodeMessage(msg)
		m.ConfigType = &TransportSocket_TypedConfig{msg}
		return true, err
	default:
		return false, nil
	}
}

func _TransportSocket_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*TransportSocket)
	// config_type
	switch x := m.ConfigType.(type) {
	case *TransportSocket_Config:
		s := proto.Size(x.Config)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *TransportSocket_TypedConfig:
		s := proto.Size(x.TypedConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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_base_12218511885b7551, []int{9}
}
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 (dst *SocketOption) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SocketOption.Merge(dst, 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_OneofFuncs is for the internal use of the proto package.
func (*SocketOption) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _SocketOption_OneofMarshaler, _SocketOption_OneofUnmarshaler, _SocketOption_OneofSizer, []interface{}{
		(*SocketOption_IntValue)(nil),
		(*SocketOption_BufValue)(nil),
	}
}

func _SocketOption_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*SocketOption)
	// value
	switch x := m.Value.(type) {
	case *SocketOption_IntValue:
		b.EncodeVarint(4<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.IntValue))
	case *SocketOption_BufValue:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		b.EncodeRawBytes(x.BufValue)
	case nil:
	default:
		return fmt.Errorf("SocketOption.Value has unexpected type %T", x)
	}
	return nil
}

func _SocketOption_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*SocketOption)
	switch tag {
	case 4: // value.int_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &SocketOption_IntValue{int64(x)}
		return true, err
	case 5: // value.buf_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Value = &SocketOption_BufValue{x}
		return true, err
	default:
		return false, nil
	}
}

func _SocketOption_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*SocketOption)
	// value
	switch x := m.Value.(type) {
	case *SocketOption_IntValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.IntValue))
	case *SocketOption_BufValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.BufValue)))
		n += len(x.BufValue)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type RuntimeFractionalPercent struct {
	DefaultValue         *percent.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_base_12218511885b7551, []int{10}
}
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 (dst *RuntimeFractionalPercent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RuntimeFractionalPercent.Merge(dst, 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() *percent.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_base_12218511885b7551, []int{11}
}
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 (dst *ControlPlane) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ControlPlane.Merge(dst, 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.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((*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((*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")
	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.SocketOption_SocketState", SocketOption_SocketState_name, SocketOption_SocketState_value)
}

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

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