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

package core

import (
	bytes "bytes"
	fmt "fmt"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	time "time"
)

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

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// [#not-implemented-hide:]
type TcpProtocolOptions struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TcpProtocolOptions) Reset()         { *m = TcpProtocolOptions{} }
func (m *TcpProtocolOptions) String() string { return proto.CompactTextString(m) }
func (*TcpProtocolOptions) ProtoMessage()    {}
func (*TcpProtocolOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_d86476e078060b60, []int{0}
}
func (m *TcpProtocolOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TcpProtocolOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TcpProtocolOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TcpProtocolOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TcpProtocolOptions.Merge(m, src)
}
func (m *TcpProtocolOptions) XXX_Size() int {
	return m.Size()
}
func (m *TcpProtocolOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_TcpProtocolOptions.DiscardUnknown(m)
}

var xxx_messageInfo_TcpProtocolOptions proto.InternalMessageInfo

type HttpProtocolOptions struct {
	// The idle timeout for upstream connection pool connections. The idle timeout is defined as the
	// period in which there are no active requests. If not set, there is no idle timeout. When the
	// idle timeout is reached the connection will be closed. Note that request based timeouts mean
	// that HTTP/2 PINGs will not keep the connection alive.
	IdleTimeout          *time.Duration `protobuf:"bytes,1,opt,name=idle_timeout,json=idleTimeout,proto3,stdduration" json:"idle_timeout,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *HttpProtocolOptions) Reset()         { *m = HttpProtocolOptions{} }
func (m *HttpProtocolOptions) String() string { return proto.CompactTextString(m) }
func (*HttpProtocolOptions) ProtoMessage()    {}
func (*HttpProtocolOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_d86476e078060b60, []int{1}
}
func (m *HttpProtocolOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HttpProtocolOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HttpProtocolOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HttpProtocolOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HttpProtocolOptions.Merge(m, src)
}
func (m *HttpProtocolOptions) XXX_Size() int {
	return m.Size()
}
func (m *HttpProtocolOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_HttpProtocolOptions.DiscardUnknown(m)
}

var xxx_messageInfo_HttpProtocolOptions proto.InternalMessageInfo

func (m *HttpProtocolOptions) GetIdleTimeout() *time.Duration {
	if m != nil {
		return m.IdleTimeout
	}
	return nil
}

type Http1ProtocolOptions struct {
	// Handle HTTP requests with absolute URLs in the requests. These requests
	// are generally sent by clients to forward/explicit proxies. This allows clients to configure
	// envoy as their HTTP proxy. In Unix, for example, this is typically done by setting the
	// *http_proxy* environment variable.
	AllowAbsoluteUrl *types.BoolValue `protobuf:"bytes,1,opt,name=allow_absolute_url,json=allowAbsoluteUrl,proto3" json:"allow_absolute_url,omitempty"`
	// Handle incoming HTTP/1.0 and HTTP 0.9 requests.
	// This is off by default, and not fully standards compliant. There is support for pre-HTTP/1.1
	// style connect logic, dechunking, and handling lack of client host iff
	// *default_host_for_http_10* is configured.
	AcceptHttp_10 bool `protobuf:"varint,2,opt,name=accept_http_10,json=acceptHttp10,proto3" json:"accept_http_10,omitempty"`
	// A default host for HTTP/1.0 requests. This is highly suggested if *accept_http_10* is true as
	// Envoy does not otherwise support HTTP/1.0 without a Host header.
	// This is a no-op if *accept_http_10* is not true.
	DefaultHostForHttp_10 string   `protobuf:"bytes,3,opt,name=default_host_for_http_10,json=defaultHostForHttp10,proto3" json:"default_host_for_http_10,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

func (m *Http1ProtocolOptions) Reset()         { *m = Http1ProtocolOptions{} }
func (m *Http1ProtocolOptions) String() string { return proto.CompactTextString(m) }
func (*Http1ProtocolOptions) ProtoMessage()    {}
func (*Http1ProtocolOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_d86476e078060b60, []int{2}
}
func (m *Http1ProtocolOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Http1ProtocolOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Http1ProtocolOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Http1ProtocolOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Http1ProtocolOptions.Merge(m, src)
}
func (m *Http1ProtocolOptions) XXX_Size() int {
	return m.Size()
}
func (m *Http1ProtocolOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_Http1ProtocolOptions.DiscardUnknown(m)
}

var xxx_messageInfo_Http1ProtocolOptions proto.InternalMessageInfo

func (m *Http1ProtocolOptions) GetAllowAbsoluteUrl() *types.BoolValue {
	if m != nil {
		return m.AllowAbsoluteUrl
	}
	return nil
}

func (m *Http1ProtocolOptions) GetAcceptHttp_10() bool {
	if m != nil {
		return m.AcceptHttp_10
	}
	return false
}

func (m *Http1ProtocolOptions) GetDefaultHostForHttp_10() string {
	if m != nil {
		return m.DefaultHostForHttp_10
	}
	return ""
}

// [#comment:next free field: 13]
type Http2ProtocolOptions struct {
	// `Maximum table size <https://httpwg.org/specs/rfc7541.html#rfc.section.4.2>`_
	// (in octets) that the encoder is permitted to use for the dynamic HPACK table. Valid values
	// range from 0 to 4294967295 (2^32 - 1) and defaults to 4096. 0 effectively disables header
	// compression.
	HpackTableSize *types.UInt32Value `protobuf:"bytes,1,opt,name=hpack_table_size,json=hpackTableSize,proto3" json:"hpack_table_size,omitempty"`
	// `Maximum concurrent streams <https://httpwg.org/specs/rfc7540.html#rfc.section.5.1.2>`_
	// allowed for peer on one HTTP/2 connection. Valid values range from 1 to 2147483647 (2^31 - 1)
	// and defaults to 2147483647.
	MaxConcurrentStreams *types.UInt32Value `protobuf:"bytes,2,opt,name=max_concurrent_streams,json=maxConcurrentStreams,proto3" json:"max_concurrent_streams,omitempty"`
	// This field also acts as a soft limit on the number of bytes Envoy will buffer per-stream in the
	// HTTP/2 codec buffers. Once the buffer reaches this pointer, watermark callbacks will fire to
	// stop the flow of data to the codec buffers.
	InitialStreamWindowSize *types.UInt32Value `protobuf:"bytes,3,opt,name=initial_stream_window_size,json=initialStreamWindowSize,proto3" json:"initial_stream_window_size,omitempty"`
	// Similar to *initial_stream_window_size*, but for connection-level flow-control
	// window. Currently, this has the same minimum/maximum/default as *initial_stream_window_size*.
	InitialConnectionWindowSize *types.UInt32Value `protobuf:"bytes,4,opt,name=initial_connection_window_size,json=initialConnectionWindowSize,proto3" json:"initial_connection_window_size,omitempty"`
	// Allows proxying Websocket and other upgrades over H2 connect.
	AllowConnect bool `protobuf:"varint,5,opt,name=allow_connect,json=allowConnect,proto3" json:"allow_connect,omitempty"`
	// [#not-implemented-hide:] Hiding until envoy has full metadata support.
	// Still under implementation. DO NOT USE.
	//
	// Allows metadata. See [metadata
	// docs](https://github.com/envoyproxy/envoy/blob/master/source/docs/h2_metadata.md) for more
	// information.
	AllowMetadata bool `protobuf:"varint,6,opt,name=allow_metadata,json=allowMetadata,proto3" json:"allow_metadata,omitempty"`
	// Limit the number of pending outbound downstream frames of all types (frames that are waiting to
	// be written into the socket). Exceeding this limit triggers flood mitigation and connection is
	// terminated. The ``http2.outbound_flood`` stat tracks the number of terminated connections due
	// to flood mitigation. The default limit is 10000.
	// [#comment:TODO: implement same limits for upstream outbound frames as well.]
	MaxOutboundFrames *types.UInt32Value `protobuf:"bytes,7,opt,name=max_outbound_frames,json=maxOutboundFrames,proto3" json:"max_outbound_frames,omitempty"`
	// Limit the number of pending outbound downstream frames of types PING, SETTINGS and RST_STREAM,
	// preventing high memory utilization when receiving continuous stream of these frames. Exceeding
	// this limit triggers flood mitigation and connection is terminated. The
	// ``http2.outbound_control_flood`` stat tracks the number of terminated connections due to flood
	// mitigation. The default limit is 1000.
	// [#comment:TODO: implement same limits for upstream outbound frames as well.]
	MaxOutboundControlFrames *types.UInt32Value `protobuf:"bytes,8,opt,name=max_outbound_control_frames,json=maxOutboundControlFrames,proto3" json:"max_outbound_control_frames,omitempty"`
	// Limit the number of consecutive inbound frames of types HEADERS, CONTINUATION and DATA with an
	// empty payload and no end stream flag. Those frames have no legitimate use and are abusive, but
	// might be a result of a broken HTTP/2 implementation. The `http2.inbound_empty_frames_flood``
	// stat tracks the number of connections terminated due to flood mitigation.
	// Setting this to 0 will terminate connection upon receiving first frame with an empty payload
	// and no end stream flag. The default limit is 1.
	// [#comment:TODO: implement same limits for upstream inbound frames as well.]
	MaxConsecutiveInboundFramesWithEmptyPayload *types.UInt32Value `protobuf:"bytes,9,opt,name=max_consecutive_inbound_frames_with_empty_payload,json=maxConsecutiveInboundFramesWithEmptyPayload,proto3" json:"max_consecutive_inbound_frames_with_empty_payload,omitempty"`
	// Limit the number of inbound PRIORITY frames allowed per each opened stream. If the number
	// of PRIORITY frames received over the lifetime of connection exceeds the value calculated
	// using this formula::
	//
	//     max_inbound_priority_frames_per_stream * (1 + inbound_streams)
	//
	// the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks
	// the number of connections terminated due to flood mitigation. The default limit is 100.
	// [#comment:TODO: implement same limits for upstream inbound frames as well.]
	MaxInboundPriorityFramesPerStream *types.UInt32Value `protobuf:"bytes,10,opt,name=max_inbound_priority_frames_per_stream,json=maxInboundPriorityFramesPerStream,proto3" json:"max_inbound_priority_frames_per_stream,omitempty"`
	// Limit the number of inbound WINDOW_UPDATE frames allowed per DATA frame sent. If the number
	// of WINDOW_UPDATE frames received over the lifetime of connection exceeds the value calculated
	// using this formula::
	//
	//     1 + 2 * (inbound_streams +
	//              max_inbound_window_update_frames_per_data_frame_sent * outbound_data_frames)
	//
	// the connection is terminated. The ``http2.inbound_priority_frames_flood`` stat tracks
	// the number of connections terminated due to flood mitigation. The default limit is 10.
	// Setting this to 1 should be enough to support HTTP/2 implementations with basic flow control,
	// but more complex implementations that try to estimate available bandwidth require at least 2.
	// [#comment:TODO: implement same limits for upstream inbound frames as well.]
	MaxInboundWindowUpdateFramesPerDataFrameSent *types.UInt32Value `protobuf:"bytes,11,opt,name=max_inbound_window_update_frames_per_data_frame_sent,json=maxInboundWindowUpdateFramesPerDataFrameSent,proto3" json:"max_inbound_window_update_frames_per_data_frame_sent,omitempty"`
	// Allows invalid HTTP messaging and headers. When this option is disabled (default), then
	// the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However,
	// when this option is enabled, only the offending stream is terminated.
	//
	// See [RFC7540, sec. 8.1](https://tools.ietf.org/html/rfc7540#section-8.1) for details.
	StreamErrorOnInvalidHttpMessaging bool     `protobuf:"varint,12,opt,name=stream_error_on_invalid_http_messaging,json=streamErrorOnInvalidHttpMessaging,proto3" json:"stream_error_on_invalid_http_messaging,omitempty"`
	XXX_NoUnkeyedLiteral              struct{} `json:"-"`
	XXX_unrecognized                  []byte   `json:"-"`
	XXX_sizecache                     int32    `json:"-"`
}

func (m *Http2ProtocolOptions) Reset()         { *m = Http2ProtocolOptions{} }
func (m *Http2ProtocolOptions) String() string { return proto.CompactTextString(m) }
func (*Http2ProtocolOptions) ProtoMessage()    {}
func (*Http2ProtocolOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_d86476e078060b60, []int{3}
}
func (m *Http2ProtocolOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Http2ProtocolOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Http2ProtocolOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Http2ProtocolOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Http2ProtocolOptions.Merge(m, src)
}
func (m *Http2ProtocolOptions) XXX_Size() int {
	return m.Size()
}
func (m *Http2ProtocolOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_Http2ProtocolOptions.DiscardUnknown(m)
}

var xxx_messageInfo_Http2ProtocolOptions proto.InternalMessageInfo

func (m *Http2ProtocolOptions) GetHpackTableSize() *types.UInt32Value {
	if m != nil {
		return m.HpackTableSize
	}
	return nil
}

func (m *Http2ProtocolOptions) GetMaxConcurrentStreams() *types.UInt32Value {
	if m != nil {
		return m.MaxConcurrentStreams
	}
	return nil
}

func (m *Http2ProtocolOptions) GetInitialStreamWindowSize() *types.UInt32Value {
	if m != nil {
		return m.InitialStreamWindowSize
	}
	return nil
}

func (m *Http2ProtocolOptions) GetInitialConnectionWindowSize() *types.UInt32Value {
	if m != nil {
		return m.InitialConnectionWindowSize
	}
	return nil
}

func (m *Http2ProtocolOptions) GetAllowConnect() bool {
	if m != nil {
		return m.AllowConnect
	}
	return false
}

func (m *Http2ProtocolOptions) GetAllowMetadata() bool {
	if m != nil {
		return m.AllowMetadata
	}
	return false
}

func (m *Http2ProtocolOptions) GetMaxOutboundFrames() *types.UInt32Value {
	if m != nil {
		return m.MaxOutboundFrames
	}
	return nil
}

func (m *Http2ProtocolOptions) GetMaxOutboundControlFrames() *types.UInt32Value {
	if m != nil {
		return m.MaxOutboundControlFrames
	}
	return nil
}

func (m *Http2ProtocolOptions) GetMaxConsecutiveInboundFramesWithEmptyPayload() *types.UInt32Value {
	if m != nil {
		return m.MaxConsecutiveInboundFramesWithEmptyPayload
	}
	return nil
}

func (m *Http2ProtocolOptions) GetMaxInboundPriorityFramesPerStream() *types.UInt32Value {
	if m != nil {
		return m.MaxInboundPriorityFramesPerStream
	}
	return nil
}

func (m *Http2ProtocolOptions) GetMaxInboundWindowUpdateFramesPerDataFrameSent() *types.UInt32Value {
	if m != nil {
		return m.MaxInboundWindowUpdateFramesPerDataFrameSent
	}
	return nil
}

func (m *Http2ProtocolOptions) GetStreamErrorOnInvalidHttpMessaging() bool {
	if m != nil {
		return m.StreamErrorOnInvalidHttpMessaging
	}
	return false
}

// [#not-implemented-hide:]
type GrpcProtocolOptions struct {
	Http2ProtocolOptions *Http2ProtocolOptions `protobuf:"bytes,1,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *GrpcProtocolOptions) Reset()         { *m = GrpcProtocolOptions{} }
func (m *GrpcProtocolOptions) String() string { return proto.CompactTextString(m) }
func (*GrpcProtocolOptions) ProtoMessage()    {}
func (*GrpcProtocolOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_d86476e078060b60, []int{4}
}
func (m *GrpcProtocolOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GrpcProtocolOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GrpcProtocolOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GrpcProtocolOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GrpcProtocolOptions.Merge(m, src)
}
func (m *GrpcProtocolOptions) XXX_Size() int {
	return m.Size()
}
func (m *GrpcProtocolOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_GrpcProtocolOptions.DiscardUnknown(m)
}

var xxx_messageInfo_GrpcProtocolOptions proto.InternalMessageInfo

func (m *GrpcProtocolOptions) GetHttp2ProtocolOptions() *Http2ProtocolOptions {
	if m != nil {
		return m.Http2ProtocolOptions
	}
	return nil
}

func init() {
	proto.RegisterType((*TcpProtocolOptions)(nil), "envoy.api.v2.core.TcpProtocolOptions")
	proto.RegisterType((*HttpProtocolOptions)(nil), "envoy.api.v2.core.HttpProtocolOptions")
	proto.RegisterType((*Http1ProtocolOptions)(nil), "envoy.api.v2.core.Http1ProtocolOptions")
	proto.RegisterType((*Http2ProtocolOptions)(nil), "envoy.api.v2.core.Http2ProtocolOptions")
	proto.RegisterType((*GrpcProtocolOptions)(nil), "envoy.api.v2.core.GrpcProtocolOptions")
}

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

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

func (this *TcpProtocolOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TcpProtocolOptions)
	if !ok {
		that2, ok := that.(TcpProtocolOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *HttpProtocolOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HttpProtocolOptions)
	if !ok {
		that2, ok := that.(HttpProtocolOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.IdleTimeout != nil && that1.IdleTimeout != nil {
		if *this.IdleTimeout != *that1.IdleTimeout {
			return false
		}
	} else if this.IdleTimeout != nil {
		return false
	} else if that1.IdleTimeout != nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Http1ProtocolOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Http1ProtocolOptions)
	if !ok {
		that2, ok := that.(Http1ProtocolOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.AllowAbsoluteUrl.Equal(that1.AllowAbsoluteUrl) {
		return false
	}
	if this.AcceptHttp_10 != that1.AcceptHttp_10 {
		return false
	}
	if this.DefaultHostForHttp_10 != that1.DefaultHostForHttp_10 {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Http2ProtocolOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Http2ProtocolOptions)
	if !ok {
		that2, ok := that.(Http2ProtocolOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.HpackTableSize.Equal(that1.HpackTableSize) {
		return false
	}
	if !this.MaxConcurrentStreams.Equal(that1.MaxConcurrentStreams) {
		return false
	}
	if !this.InitialStreamWindowSize.Equal(that1.InitialStreamWindowSize) {
		return false
	}
	if !this.InitialConnectionWindowSize.Equal(that1.InitialConnectionWindowSize) {
		return false
	}
	if this.AllowConnect != that1.AllowConnect {
		return false
	}
	if this.AllowMetadata != that1.AllowMetadata {
		return false
	}
	if !this.MaxOutboundFrames.Equal(that1.MaxOutboundFrames) {
		return false
	}
	if !this.MaxOutboundControlFrames.Equal(that1.MaxOutboundControlFrames) {
		return false
	}
	if !this.MaxConsecutiveInboundFramesWithEmptyPayload.Equal(that1.MaxConsecutiveInboundFramesWithEmptyPayload) {
		return false
	}
	if !this.MaxInboundPriorityFramesPerStream.Equal(that1.MaxInboundPriorityFramesPerStream) {
		return false
	}
	if !this.MaxInboundWindowUpdateFramesPerDataFrameSent.Equal(that1.MaxInboundWindowUpdateFramesPerDataFrameSent) {
		return false
	}
	if this.StreamErrorOnInvalidHttpMessaging != that1.StreamErrorOnInvalidHttpMessaging {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *GrpcProtocolOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GrpcProtocolOptions)
	if !ok {
		that2, ok := that.(GrpcProtocolOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Http2ProtocolOptions.Equal(that1.Http2ProtocolOptions) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (m *TcpProtocolOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TcpProtocolOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *HttpProtocolOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HttpProtocolOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.IdleTimeout != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(*m.IdleTimeout)))
		n1, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.IdleTimeout, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Http1ProtocolOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Http1ProtocolOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.AllowAbsoluteUrl != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.AllowAbsoluteUrl.Size()))
		n2, err := m.AllowAbsoluteUrl.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.AcceptHttp_10 {
		dAtA[i] = 0x10
		i++
		if m.AcceptHttp_10 {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.DefaultHostForHttp_10) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(len(m.DefaultHostForHttp_10)))
		i += copy(dAtA[i:], m.DefaultHostForHttp_10)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Http2ProtocolOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Http2ProtocolOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.HpackTableSize != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.HpackTableSize.Size()))
		n3, err := m.HpackTableSize.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.MaxConcurrentStreams != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.MaxConcurrentStreams.Size()))
		n4, err := m.MaxConcurrentStreams.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.InitialStreamWindowSize != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.InitialStreamWindowSize.Size()))
		n5, err := m.InitialStreamWindowSize.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.InitialConnectionWindowSize != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.InitialConnectionWindowSize.Size()))
		n6, err := m.InitialConnectionWindowSize.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.AllowConnect {
		dAtA[i] = 0x28
		i++
		if m.AllowConnect {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.AllowMetadata {
		dAtA[i] = 0x30
		i++
		if m.AllowMetadata {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.MaxOutboundFrames != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.MaxOutboundFrames.Size()))
		n7, err := m.MaxOutboundFrames.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.MaxOutboundControlFrames != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.MaxOutboundControlFrames.Size()))
		n8, err := m.MaxOutboundControlFrames.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.MaxConsecutiveInboundFramesWithEmptyPayload != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.MaxConsecutiveInboundFramesWithEmptyPayload.Size()))
		n9, err := m.MaxConsecutiveInboundFramesWithEmptyPayload.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.MaxInboundPriorityFramesPerStream != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.MaxInboundPriorityFramesPerStream.Size()))
		n10, err := m.MaxInboundPriorityFramesPerStream.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.MaxInboundWindowUpdateFramesPerDataFrameSent != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.MaxInboundWindowUpdateFramesPerDataFrameSent.Size()))
		n11, err := m.MaxInboundWindowUpdateFramesPerDataFrameSent.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.StreamErrorOnInvalidHttpMessaging {
		dAtA[i] = 0x60
		i++
		if m.StreamErrorOnInvalidHttpMessaging {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GrpcProtocolOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GrpcProtocolOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Http2ProtocolOptions != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtocol(dAtA, i, uint64(m.Http2ProtocolOptions.Size()))
		n12, err := m.Http2ProtocolOptions.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintProtocol(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *TcpProtocolOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HttpProtocolOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IdleTimeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.IdleTimeout)
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Http1ProtocolOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AllowAbsoluteUrl != nil {
		l = m.AllowAbsoluteUrl.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.AcceptHttp_10 {
		n += 2
	}
	l = len(m.DefaultHostForHttp_10)
	if l > 0 {
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Http2ProtocolOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HpackTableSize != nil {
		l = m.HpackTableSize.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.MaxConcurrentStreams != nil {
		l = m.MaxConcurrentStreams.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.InitialStreamWindowSize != nil {
		l = m.InitialStreamWindowSize.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.InitialConnectionWindowSize != nil {
		l = m.InitialConnectionWindowSize.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.AllowConnect {
		n += 2
	}
	if m.AllowMetadata {
		n += 2
	}
	if m.MaxOutboundFrames != nil {
		l = m.MaxOutboundFrames.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.MaxOutboundControlFrames != nil {
		l = m.MaxOutboundControlFrames.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.MaxConsecutiveInboundFramesWithEmptyPayload != nil {
		l = m.MaxConsecutiveInboundFramesWithEmptyPayload.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.MaxInboundPriorityFramesPerStream != nil {
		l = m.MaxInboundPriorityFramesPerStream.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.MaxInboundWindowUpdateFramesPerDataFrameSent != nil {
		l = m.MaxInboundWindowUpdateFramesPerDataFrameSent.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.StreamErrorOnInvalidHttpMessaging {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GrpcProtocolOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Http2ProtocolOptions != nil {
		l = m.Http2ProtocolOptions.Size()
		n += 1 + l + sovProtocol(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovProtocol(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozProtocol(x uint64) (n int) {
	return sovProtocol(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TcpProtocolOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProtocol
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TcpProtocolOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TcpProtocolOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipProtocol(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HttpProtocolOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProtocol
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HttpProtocolOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HttpProtocolOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdleTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdleTimeout == nil {
				m.IdleTimeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.IdleTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtocol(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Http1ProtocolOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProtocol
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Http1ProtocolOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Http1ProtocolOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowAbsoluteUrl", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AllowAbsoluteUrl == nil {
				m.AllowAbsoluteUrl = &types.BoolValue{}
			}
			if err := m.AllowAbsoluteUrl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptHttp_10", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AcceptHttp_10 = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultHostForHttp_10", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultHostForHttp_10 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtocol(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Http2ProtocolOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProtocol
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Http2ProtocolOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Http2ProtocolOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HpackTableSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.HpackTableSize == nil {
				m.HpackTableSize = &types.UInt32Value{}
			}
			if err := m.HpackTableSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxConcurrentStreams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxConcurrentStreams == nil {
				m.MaxConcurrentStreams = &types.UInt32Value{}
			}
			if err := m.MaxConcurrentStreams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialStreamWindowSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InitialStreamWindowSize == nil {
				m.InitialStreamWindowSize = &types.UInt32Value{}
			}
			if err := m.InitialStreamWindowSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialConnectionWindowSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InitialConnectionWindowSize == nil {
				m.InitialConnectionWindowSize = &types.UInt32Value{}
			}
			if err := m.InitialConnectionWindowSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowConnect", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowConnect = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowMetadata", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowMetadata = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxOutboundFrames", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxOutboundFrames == nil {
				m.MaxOutboundFrames = &types.UInt32Value{}
			}
			if err := m.MaxOutboundFrames.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxOutboundControlFrames", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxOutboundControlFrames == nil {
				m.MaxOutboundControlFrames = &types.UInt32Value{}
			}
			if err := m.MaxOutboundControlFrames.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxConsecutiveInboundFramesWithEmptyPayload", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxConsecutiveInboundFramesWithEmptyPayload == nil {
				m.MaxConsecutiveInboundFramesWithEmptyPayload = &types.UInt32Value{}
			}
			if err := m.MaxConsecutiveInboundFramesWithEmptyPayload.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxInboundPriorityFramesPerStream", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxInboundPriorityFramesPerStream == nil {
				m.MaxInboundPriorityFramesPerStream = &types.UInt32Value{}
			}
			if err := m.MaxInboundPriorityFramesPerStream.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxInboundWindowUpdateFramesPerDataFrameSent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MaxInboundWindowUpdateFramesPerDataFrameSent == nil {
				m.MaxInboundWindowUpdateFramesPerDataFrameSent = &types.UInt32Value{}
			}
			if err := m.MaxInboundWindowUpdateFramesPerDataFrameSent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamErrorOnInvalidHttpMessaging", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StreamErrorOnInvalidHttpMessaging = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipProtocol(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GrpcProtocolOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowProtocol
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GrpcProtocolOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GrpcProtocolOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Http2ProtocolOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtocol
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtocol
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Http2ProtocolOptions == nil {
				m.Http2ProtocolOptions = &Http2ProtocolOptions{}
			}
			if err := m.Http2ProtocolOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtocol(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtocol
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipProtocol(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowProtocol
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowProtocol
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthProtocol
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthProtocol
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowProtocol
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipProtocol(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthProtocol
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthProtocol = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtocol   = fmt.Errorf("proto: integer overflow")
)
