data.pb.go

// Code generated by protoc-gen-gogo.
// source: cockroach/pkg/sql/distsqlrun/data.proto
// DO NOT EDIT!

package distsqlrun

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import cockroach_roachpb3 "github.com/cockroachdb/cockroach/pkg/roachpb"
import cockroach_roachpb2 "github.com/cockroachdb/cockroach/pkg/roachpb"
import cockroach_pgerror "github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
import cockroach_sql_sqlbase1 "github.com/cockroachdb/cockroach/pkg/sql/sqlbase"
import cockroach_sql_sqlbase2 "github.com/cockroachdb/cockroach/pkg/sql/sqlbase"
import cockroach_util_tracing "github.com/cockroachdb/cockroach/pkg/util/tracing"

import io "io"

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

// The direction of the desired ordering for a column.
type Ordering_Column_Direction int32

const (
	Ordering_Column_ASC  Ordering_Column_Direction = 0
	Ordering_Column_DESC Ordering_Column_Direction = 1
)

var Ordering_Column_Direction_name = map[int32]string{
	0: "ASC",
	1: "DESC",
}
var Ordering_Column_Direction_value = map[string]int32{
	"ASC":  0,
	"DESC": 1,
}

func (x Ordering_Column_Direction) Enum() *Ordering_Column_Direction {
	p := new(Ordering_Column_Direction)
	*p = x
	return p
}
func (x Ordering_Column_Direction) String() string {
	return proto.EnumName(Ordering_Column_Direction_name, int32(x))
}
func (x *Ordering_Column_Direction) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Ordering_Column_Direction_value, data, "Ordering_Column_Direction")
	if err != nil {
		return err
	}
	*x = Ordering_Column_Direction(value)
	return nil
}
func (Ordering_Column_Direction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorData, []int{2, 0, 0}
}

type StreamEndpointSpec_Type int32

const (
	// Stream that is part of the local flow.
	StreamEndpointSpec_LOCAL StreamEndpointSpec_Type = 0
	// Stream that has the other endpoint on a different node.
	StreamEndpointSpec_REMOTE StreamEndpointSpec_Type = 1
	// Special stream used when in "sync flow" mode. In this mode, we return
	// results directly as part of the RPC call that set up the flow. This saves
	// overhead (extra RPCs) compared to the normal mode where the RPC just sets
	// up the flow. This type can only be used with outbound endpoints.
	StreamEndpointSpec_SYNC_RESPONSE StreamEndpointSpec_Type = 2
)

var StreamEndpointSpec_Type_name = map[int32]string{
	0: "LOCAL",
	1: "REMOTE",
	2: "SYNC_RESPONSE",
}
var StreamEndpointSpec_Type_value = map[string]int32{
	"LOCAL":         0,
	"REMOTE":        1,
	"SYNC_RESPONSE": 2,
}

func (x StreamEndpointSpec_Type) Enum() *StreamEndpointSpec_Type {
	p := new(StreamEndpointSpec_Type)
	*p = x
	return p
}
func (x StreamEndpointSpec_Type) String() string {
	return proto.EnumName(StreamEndpointSpec_Type_name, int32(x))
}
func (x *StreamEndpointSpec_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(StreamEndpointSpec_Type_value, data, "StreamEndpointSpec_Type")
	if err != nil {
		return err
	}
	*x = StreamEndpointSpec_Type(value)
	return nil
}
func (StreamEndpointSpec_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorData, []int{3, 0}
}

type InputSyncSpec_Type int32

const (
	// Rows from the input streams are interleaved arbitrarily.
	InputSyncSpec_UNORDERED InputSyncSpec_Type = 0
	// The input streams are guaranteed to be ordered according to the column
	// ordering field; rows from the streams are interleaved to preserve that
	// ordering.
	InputSyncSpec_ORDERED InputSyncSpec_Type = 1
)

var InputSyncSpec_Type_name = map[int32]string{
	0: "UNORDERED",
	1: "ORDERED",
}
var InputSyncSpec_Type_value = map[string]int32{
	"UNORDERED": 0,
	"ORDERED":   1,
}

func (x InputSyncSpec_Type) Enum() *InputSyncSpec_Type {
	p := new(InputSyncSpec_Type)
	*p = x
	return p
}
func (x InputSyncSpec_Type) String() string {
	return proto.EnumName(InputSyncSpec_Type_name, int32(x))
}
func (x *InputSyncSpec_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(InputSyncSpec_Type_value, data, "InputSyncSpec_Type")
	if err != nil {
		return err
	}
	*x = InputSyncSpec_Type(value)
	return nil
}
func (InputSyncSpec_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorData, []int{4, 0} }

type OutputRouterSpec_Type int32

const (
	// Single output stream.
	OutputRouterSpec_PASS_THROUGH OutputRouterSpec_Type = 0
	// Each row is sent to all output streams.
	OutputRouterSpec_MIRROR OutputRouterSpec_Type = 1
	// Each row is sent to one stream, chosen by hashing certain columns of
	// the row (specified by the hash_columns field).
	OutputRouterSpec_BY_HASH OutputRouterSpec_Type = 2
	// Each row is sent to one stream, chosen according to preset boundaries
	// for the values of certain columns of the row.
	OutputRouterSpec_BY_RANGE OutputRouterSpec_Type = 3
)

var OutputRouterSpec_Type_name = map[int32]string{
	0: "PASS_THROUGH",
	1: "MIRROR",
	2: "BY_HASH",
	3: "BY_RANGE",
}
var OutputRouterSpec_Type_value = map[string]int32{
	"PASS_THROUGH": 0,
	"MIRROR":       1,
	"BY_HASH":      2,
	"BY_RANGE":     3,
}

func (x OutputRouterSpec_Type) Enum() *OutputRouterSpec_Type {
	p := new(OutputRouterSpec_Type)
	*p = x
	return p
}
func (x OutputRouterSpec_Type) String() string {
	return proto.EnumName(OutputRouterSpec_Type_name, int32(x))
}
func (x *OutputRouterSpec_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(OutputRouterSpec_Type_value, data, "OutputRouterSpec_Type")
	if err != nil {
		return err
	}
	*x = OutputRouterSpec_Type(value)
	return nil
}
func (OutputRouterSpec_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorData, []int{5, 0} }

// Error is a generic representation including a string message.
type Error struct {
	// Types that are valid to be assigned to Detail:
	//	*Error_PGError
	//	*Error_RetryableTxnError
	Detail isError_Detail `protobuf_oneof:"detail"`
}

func (m *Error) Reset()                    { *m = Error{} }
func (*Error) ProtoMessage()               {}
func (*Error) Descriptor() ([]byte, []int) { return fileDescriptorData, []int{0} }

type isError_Detail interface {
	isError_Detail()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Error_PGError struct {
	PGError *cockroach_pgerror.Error `protobuf:"bytes,1,opt,name=pg_error,json=pgError,oneof"`
}
type Error_RetryableTxnError struct {
	RetryableTxnError *cockroach_roachpb2.UnhandledRetryableError `protobuf:"bytes,2,opt,name=retryableTxnError,oneof"`
}

func (*Error_PGError) isError_Detail()           {}
func (*Error_RetryableTxnError) isError_Detail() {}

func (m *Error) GetDetail() isError_Detail {
	if m != nil {
		return m.Detail
	}
	return nil
}

func (m *Error) GetPGError() *cockroach_pgerror.Error {
	if x, ok := m.GetDetail().(*Error_PGError); ok {
		return x.PGError
	}
	return nil
}

func (m *Error) GetRetryableTxnError() *cockroach_roachpb2.UnhandledRetryableError {
	if x, ok := m.GetDetail().(*Error_RetryableTxnError); ok {
		return x.RetryableTxnError
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Error) 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 _Error_OneofMarshaler, _Error_OneofUnmarshaler, _Error_OneofSizer, []interface{}{
		(*Error_PGError)(nil),
		(*Error_RetryableTxnError)(nil),
	}
}

func _Error_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Error)
	// detail
	switch x := m.Detail.(type) {
	case *Error_PGError:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PGError); err != nil {
			return err
		}
	case *Error_RetryableTxnError:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RetryableTxnError); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Error.Detail has unexpected type %T", x)
	}
	return nil
}

func _Error_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Error)
	switch tag {
	case 1: // detail.pg_error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(cockroach_pgerror.Error)
		err := b.DecodeMessage(msg)
		m.Detail = &Error_PGError{msg}
		return true, err
	case 2: // detail.retryableTxnError
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(cockroach_roachpb2.UnhandledRetryableError)
		err := b.DecodeMessage(msg)
		m.Detail = &Error_RetryableTxnError{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Error_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Error)
	// detail
	switch x := m.Detail.(type) {
	case *Error_PGError:
		s := proto.Size(x.PGError)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Error_RetryableTxnError:
		s := proto.Size(x.RetryableTxnError)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Expression struct {
	// TODO(radu): TBD how this will be used
	Version string `protobuf:"bytes,1,opt,name=version" json:"version"`
	// SQL expressions are passed as a string, with ordinal references
	// (@1, @2, @3 ..) used for "input" variables.
	Expr string `protobuf:"bytes,2,opt,name=expr" json:"expr"`
}

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

// Ordering defines an order - specifically a list of column indices and
// directions. See sqlbase.ColumnOrdering.
type Ordering struct {
	Columns []Ordering_Column `protobuf:"bytes,1,rep,name=columns" json:"columns"`
}

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

type Ordering_Column struct {
	ColIdx    uint32                    `protobuf:"varint,1,opt,name=col_idx,json=colIdx" json:"col_idx"`
	Direction Ordering_Column_Direction `protobuf:"varint,2,opt,name=direction,enum=cockroach.sql.distsqlrun.Ordering_Column_Direction" json:"direction"`
}

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

// StreamEndpointSpec describes one of the endpoints (input or output) of a physical
// stream.
type StreamEndpointSpec struct {
	Type StreamEndpointSpec_Type `protobuf:"varint,1,opt,name=type,enum=cockroach.sql.distsqlrun.StreamEndpointSpec_Type" json:"type"`
	// The ID of this stream.
	//
	// For LOCAL streams, both ends of the stream are part of the flow on this
	// machine (and there must be a corresponding endpoint with the same ID).
	//
	// For REMOTE streams, this ID is used in the ProducerHeader when connecting to
	// the other host.
	//
	// For SYNC_RESPONSE streams, the ID is unused.
	StreamID StreamID `protobuf:"varint,2,opt,name=stream_id,json=streamId,casttype=StreamID" json:"stream_id"`
	// Serving address for the target host, only used for outgoing REMOTE streams.
	TargetAddr string `protobuf:"bytes,3,opt,name=target_addr,json=targetAddr" json:"target_addr"`
}

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

// InputSyncSpec is the specification for an input synchronizer; it decides how
// to interleave rows from multiple input streams.
type InputSyncSpec struct {
	Type     InputSyncSpec_Type   `protobuf:"varint,1,opt,name=type,enum=cockroach.sql.distsqlrun.InputSyncSpec_Type" json:"type"`
	Ordering Ordering             `protobuf:"bytes,2,opt,name=ordering" json:"ordering"`
	Streams  []StreamEndpointSpec `protobuf:"bytes,3,rep,name=streams" json:"streams"`
	// Schema for the streams entering this synchronizer.
	ColumnTypes []cockroach_sql_sqlbase1.ColumnType `protobuf:"bytes,4,rep,name=column_types,json=columnTypes" json:"column_types"`
}

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

// OutputRouterSpec is the specification for the output router of a processor;
// it decides how to send results to multiple output streams.
type OutputRouterSpec struct {
	Type    OutputRouterSpec_Type `protobuf:"varint,1,opt,name=type,enum=cockroach.sql.distsqlrun.OutputRouterSpec_Type" json:"type"`
	Streams []StreamEndpointSpec  `protobuf:"bytes,2,rep,name=streams" json:"streams"`
	// Only used for the BY_HASH type; these are the indexes of the columns we are
	// hashing.
	HashColumns     []uint32                         `protobuf:"varint,3,rep,name=hash_columns,json=hashColumns" json:"hash_columns,omitempty"`
	RangeRouterSpec OutputRouterSpec_RangeRouterSpec `protobuf:"bytes,4,opt,name=range_router_spec,json=rangeRouterSpec" json:"range_router_spec"`
}

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

type OutputRouterSpec_RangeRouterSpec struct {
	// spans is a slice of Span. Input matching the Nth span will be routed to the
	// Nth stream (and thus the number of spans must match the number of streams).
	Spans []OutputRouterSpec_RangeRouterSpec_Span `protobuf:"bytes,1,rep,name=spans" json:"spans"`
	// default_dest, if not nil, is the index of the stream to send rows that do
	// not match any span. If nil, a row that does not match a span will produce
	// an error in the router.
	DefaultDest *int32 `protobuf:"varint,2,opt,name=default_dest,json=defaultDest" json:"default_dest,omitempty"`
	// encodings is a slice of columns and encodings. Each will be appended to a
	// []byte, which is used as input to the spans. Columns from the input rows
	// potentially need to be recoded to match the encoding used for the spans.
	Encodings []OutputRouterSpec_RangeRouterSpec_ColumnEncoding `protobuf:"bytes,3,rep,name=encodings" json:"encodings"`
}

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

type OutputRouterSpec_RangeRouterSpec_ColumnEncoding struct {
	// column is the index of a column to encode.
	Column uint32 `protobuf:"varint,1,opt,name=column" json:"column"`
	// encoding specifies how a particular column is to be encoded for
	// generating the sort key for a row. This needs to correspond to the way
	// the Span.{start,end} keys have been generated.
	Encoding cockroach_sql_sqlbase2.DatumEncoding `protobuf:"varint,2,opt,name=encoding,enum=cockroach.sql.sqlbase.DatumEncoding" json:"encoding"`
}

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

// Span matches bytes in [start, end).
type OutputRouterSpec_RangeRouterSpec_Span struct {
	Start []byte `protobuf:"bytes,1,opt,name=start" json:"start,omitempty"`
	End   []byte `protobuf:"bytes,2,opt,name=end" json:"end,omitempty"`
}

func (m *OutputRouterSpec_RangeRouterSpec_Span) Reset()         { *m = OutputRouterSpec_RangeRouterSpec_Span{} }
func (m *OutputRouterSpec_RangeRouterSpec_Span) String() string { return proto.CompactTextString(m) }
func (*OutputRouterSpec_RangeRouterSpec_Span) ProtoMessage()    {}
func (*OutputRouterSpec_RangeRouterSpec_Span) Descriptor() ([]byte, []int) {
	return fileDescriptorData, []int{5, 0, 1}
}

type DatumInfo struct {
	Encoding cockroach_sql_sqlbase2.DatumEncoding `protobuf:"varint,1,opt,name=encoding,enum=cockroach.sql.sqlbase.DatumEncoding" json:"encoding"`
	Type     cockroach_sql_sqlbase1.ColumnType    `protobuf:"bytes,2,opt,name=type" json:"type"`
}

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

// ProducerHeader is a message that is sent once at the beginning of a stream.
type ProducerHeader struct {
	FlowID   FlowID   `protobuf:"bytes,1,opt,name=flow_id,json=flowId,customtype=FlowID" json:"flow_id"`
	StreamID StreamID `protobuf:"varint,2,opt,name=stream_id,json=streamId,casttype=StreamID" json:"stream_id"`
}

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

// ProducerData is a message that can be sent multiple times as part of a stream
// from a producer to a consumer. It contains 0 or more rows and/or 0 or more
// metadata messages.
type ProducerData struct {
	// A bunch of rows, encoded. Each datum is encoded according to the
	// corresponding DatumInfo.
	RawBytes []byte `protobuf:"bytes,1,opt,name=raw_bytes,json=rawBytes" json:"raw_bytes,omitempty"`
	// In the special case when the stream contains empty rows, the count is
	// passed instead.
	NumEmptyRows int32 `protobuf:"varint,3,opt,name=num_empty_rows,json=numEmptyRows" json:"num_empty_rows"`
	// A bunch of metadata messages.
	Metadata []RemoteProducerMetadata `protobuf:"bytes,2,rep,name=metadata" json:"metadata"`
}

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

type ProducerMessage struct {
	Header *ProducerHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	// Typing information. There will be one DatumInfo for each element in a row.
	// This field has to be populated on, or before, a ProducerMessage with data
	// in it, and can only be populated once.
	// TODO(andrei): It'd be nice if the typing information for streams would be
	// configured statically at plan creation time, instead of being discovered
	// dynamically through the first rows that flow.
	Typing []DatumInfo  `protobuf:"bytes,2,rep,name=typing" json:"typing"`
	Data   ProducerData `protobuf:"bytes,3,opt,name=data" json:"data"`
}

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

// RemoteProducerMetadata represents records that a producer wants to pass to
// a consumer, other than data rows. It's named RemoteProducerMetadata to not
// clash with ProducerMetadata, which is used internally within a node and has
// a different go error instead of a proto error inside.
type RemoteProducerMetadata struct {
	// Types that are valid to be assigned to Value:
	//	*RemoteProducerMetadata_RangeInfo
	//	*RemoteProducerMetadata_Error
	//	*RemoteProducerMetadata_TraceData_
	Value isRemoteProducerMetadata_Value `protobuf_oneof:"value"`
}

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

type isRemoteProducerMetadata_Value interface {
	isRemoteProducerMetadata_Value()
	MarshalTo([]byte) (int, error)
	Size() int
}

type RemoteProducerMetadata_RangeInfo struct {
	RangeInfo *RemoteProducerMetadata_RangeInfos `protobuf:"bytes,1,opt,name=range_info,json=rangeInfo,oneof"`
}
type RemoteProducerMetadata_Error struct {
	Error *Error `protobuf:"bytes,2,opt,name=error,oneof"`
}
type RemoteProducerMetadata_TraceData_ struct {
	TraceData *RemoteProducerMetadata_TraceData `protobuf:"bytes,3,opt,name=trace_data,json=traceData,oneof"`
}

func (*RemoteProducerMetadata_RangeInfo) isRemoteProducerMetadata_Value()  {}
func (*RemoteProducerMetadata_Error) isRemoteProducerMetadata_Value()      {}
func (*RemoteProducerMetadata_TraceData_) isRemoteProducerMetadata_Value() {}

func (m *RemoteProducerMetadata) GetValue() isRemoteProducerMetadata_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *RemoteProducerMetadata) GetRangeInfo() *RemoteProducerMetadata_RangeInfos {
	if x, ok := m.GetValue().(*RemoteProducerMetadata_RangeInfo); ok {
		return x.RangeInfo
	}
	return nil
}

func (m *RemoteProducerMetadata) GetError() *Error {
	if x, ok := m.GetValue().(*RemoteProducerMetadata_Error); ok {
		return x.Error
	}
	return nil
}

func (m *RemoteProducerMetadata) GetTraceData() *RemoteProducerMetadata_TraceData {
	if x, ok := m.GetValue().(*RemoteProducerMetadata_TraceData_); ok {
		return x.TraceData
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*RemoteProducerMetadata) 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 _RemoteProducerMetadata_OneofMarshaler, _RemoteProducerMetadata_OneofUnmarshaler, _RemoteProducerMetadata_OneofSizer, []interface{}{
		(*RemoteProducerMetadata_RangeInfo)(nil),
		(*RemoteProducerMetadata_Error)(nil),
		(*RemoteProducerMetadata_TraceData_)(nil),
	}
}

func _RemoteProducerMetadata_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*RemoteProducerMetadata)
	// value
	switch x := m.Value.(type) {
	case *RemoteProducerMetadata_RangeInfo:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RangeInfo); err != nil {
			return err
		}
	case *RemoteProducerMetadata_Error:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *RemoteProducerMetadata_TraceData_:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TraceData); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("RemoteProducerMetadata.Value has unexpected type %T", x)
	}
	return nil
}

func _RemoteProducerMetadata_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*RemoteProducerMetadata)
	switch tag {
	case 1: // value.range_info
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RemoteProducerMetadata_RangeInfos)
		err := b.DecodeMessage(msg)
		m.Value = &RemoteProducerMetadata_RangeInfo{msg}
		return true, err
	case 2: // value.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Error)
		err := b.DecodeMessage(msg)
		m.Value = &RemoteProducerMetadata_Error{msg}
		return true, err
	case 3: // value.trace_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RemoteProducerMetadata_TraceData)
		err := b.DecodeMessage(msg)
		m.Value = &RemoteProducerMetadata_TraceData_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _RemoteProducerMetadata_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*RemoteProducerMetadata)
	// value
	switch x := m.Value.(type) {
	case *RemoteProducerMetadata_RangeInfo:
		s := proto.Size(x.RangeInfo)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RemoteProducerMetadata_Error:
		s := proto.Size(x.Error)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *RemoteProducerMetadata_TraceData_:
		s := proto.Size(x.TraceData)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type RemoteProducerMetadata_RangeInfos struct {
	RangeInfo []cockroach_roachpb3.RangeInfo `protobuf:"bytes,1,rep,name=range_info,json=rangeInfo" json:"range_info"`
}

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

type RemoteProducerMetadata_TraceData struct {
	CollectedSpans []cockroach_util_tracing.RecordedSpan `protobuf:"bytes,1,rep,name=collected_spans,json=collectedSpans" json:"collected_spans"`
}

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

// DistSQLVersionGossipInfo represents the DistSQL server version information
// that gets gossiped for each node. This is used by planners to avoid planning
// on nodes with incompatible version during rolling cluster updates.
//
// For the meaning of the fields, see the corresponding constants in
// distsqlrun/server.go.
type DistSQLVersionGossipInfo struct {
	Version            DistSQLVersion `protobuf:"varint,1,opt,name=version,casttype=DistSQLVersion" json:"version"`
	MinAcceptedVersion DistSQLVersion `protobuf:"varint,2,opt,name=min_accepted_version,json=minAcceptedVersion,casttype=DistSQLVersion" json:"min_accepted_version"`
}

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

func init() {
	proto.RegisterType((*Error)(nil), "cockroach.sql.distsqlrun.Error")
	proto.RegisterType((*Expression)(nil), "cockroach.sql.distsqlrun.Expression")
	proto.RegisterType((*Ordering)(nil), "cockroach.sql.distsqlrun.Ordering")
	proto.RegisterType((*Ordering_Column)(nil), "cockroach.sql.distsqlrun.Ordering.Column")
	proto.RegisterType((*StreamEndpointSpec)(nil), "cockroach.sql.distsqlrun.StreamEndpointSpec")
	proto.RegisterType((*InputSyncSpec)(nil), "cockroach.sql.distsqlrun.InputSyncSpec")
	proto.RegisterType((*OutputRouterSpec)(nil), "cockroach.sql.distsqlrun.OutputRouterSpec")
	proto.RegisterType((*OutputRouterSpec_RangeRouterSpec)(nil), "cockroach.sql.distsqlrun.OutputRouterSpec.RangeRouterSpec")
	proto.RegisterType((*OutputRouterSpec_RangeRouterSpec_ColumnEncoding)(nil), "cockroach.sql.distsqlrun.OutputRouterSpec.RangeRouterSpec.ColumnEncoding")
	proto.RegisterType((*OutputRouterSpec_RangeRouterSpec_Span)(nil), "cockroach.sql.distsqlrun.OutputRouterSpec.RangeRouterSpec.Span")
	proto.RegisterType((*DatumInfo)(nil), "cockroach.sql.distsqlrun.DatumInfo")
	proto.RegisterType((*ProducerHeader)(nil), "cockroach.sql.distsqlrun.ProducerHeader")
	proto.RegisterType((*ProducerData)(nil), "cockroach.sql.distsqlrun.ProducerData")
	proto.RegisterType((*ProducerMessage)(nil), "cockroach.sql.distsqlrun.ProducerMessage")
	proto.RegisterType((*RemoteProducerMetadata)(nil), "cockroach.sql.distsqlrun.RemoteProducerMetadata")
	proto.RegisterType((*RemoteProducerMetadata_RangeInfos)(nil), "cockroach.sql.distsqlrun.RemoteProducerMetadata.RangeInfos")
	proto.RegisterType((*RemoteProducerMetadata_TraceData)(nil), "cockroach.sql.distsqlrun.RemoteProducerMetadata.TraceData")
	proto.RegisterType((*DistSQLVersionGossipInfo)(nil), "cockroach.sql.distsqlrun.DistSQLVersionGossipInfo")
	proto.RegisterEnum("cockroach.sql.distsqlrun.Ordering_Column_Direction", Ordering_Column_Direction_name, Ordering_Column_Direction_value)
	proto.RegisterEnum("cockroach.sql.distsqlrun.StreamEndpointSpec_Type", StreamEndpointSpec_Type_name, StreamEndpointSpec_Type_value)
	proto.RegisterEnum("cockroach.sql.distsqlrun.InputSyncSpec_Type", InputSyncSpec_Type_name, InputSyncSpec_Type_value)
	proto.RegisterEnum("cockroach.sql.distsqlrun.OutputRouterSpec_Type", OutputRouterSpec_Type_name, OutputRouterSpec_Type_value)
}
func (m *Error) 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 *Error) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Detail != nil {
		nn1, err := m.Detail.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn1
	}
	return i, nil
}

func (m *Error_PGError) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PGError != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintData(dAtA, i, uint64(m.PGError.Size()))
		n2, err := m.PGError.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}
func (m *Error_RetryableTxnError) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RetryableTxnError != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintData(dAtA, i, uint64(m.RetryableTxnError.Size()))
		n3, err := m.RetryableTxnError.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}
func (m *Expression) 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 *Expression) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintData(dAtA, i, uint64(len(m.Version)))
	i += copy(dAtA[i:], m.Version)
	dAtA[i] = 0x12
	i++
	i = encodeVarintData(dAtA, i, uint64(len(m.Expr)))
	i += copy(dAtA[i:], m.Expr)
	return i, nil
}

func (m *Ordering) 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 *Ordering) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Columns) > 0 {
		for _, msg := range m.Columns {
			dAtA[i] = 0xa
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Ordering_Column) 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 *Ordering_Column) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.ColIdx))
	dAtA[i] = 0x10
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Direction))
	return i, nil
}

func (m *StreamEndpointSpec) 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 *StreamEndpointSpec) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Type))
	dAtA[i] = 0x10
	i++
	i = encodeVarintData(dAtA, i, uint64(m.StreamID))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintData(dAtA, i, uint64(len(m.TargetAddr)))
	i += copy(dAtA[i:], m.TargetAddr)
	return i, nil
}

func (m *InputSyncSpec) 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 *InputSyncSpec) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Type))
	dAtA[i] = 0x12
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Ordering.Size()))
	n4, err := m.Ordering.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	if len(m.Streams) > 0 {
		for _, msg := range m.Streams {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.ColumnTypes) > 0 {
		for _, msg := range m.ColumnTypes {
			dAtA[i] = 0x22
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *OutputRouterSpec) 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 *OutputRouterSpec) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Type))
	if len(m.Streams) > 0 {
		for _, msg := range m.Streams {
			dAtA[i] = 0x12
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.HashColumns) > 0 {
		for _, num := range m.HashColumns {
			dAtA[i] = 0x18
			i++
			i = encodeVarintData(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x22
	i++
	i = encodeVarintData(dAtA, i, uint64(m.RangeRouterSpec.Size()))
	n5, err := m.RangeRouterSpec.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	return i, nil
}

func (m *OutputRouterSpec_RangeRouterSpec) 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 *OutputRouterSpec_RangeRouterSpec) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Spans) > 0 {
		for _, msg := range m.Spans {
			dAtA[i] = 0xa
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.DefaultDest != nil {
		dAtA[i] = 0x10
		i++
		i = encodeVarintData(dAtA, i, uint64(*m.DefaultDest))
	}
	if len(m.Encodings) > 0 {
		for _, msg := range m.Encodings {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *OutputRouterSpec_RangeRouterSpec_ColumnEncoding) 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 *OutputRouterSpec_RangeRouterSpec_ColumnEncoding) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Column))
	dAtA[i] = 0x10
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Encoding))
	return i, nil
}

func (m *OutputRouterSpec_RangeRouterSpec_Span) 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 *OutputRouterSpec_RangeRouterSpec_Span) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Start != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintData(dAtA, i, uint64(len(m.Start)))
		i += copy(dAtA[i:], m.Start)
	}
	if m.End != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintData(dAtA, i, uint64(len(m.End)))
		i += copy(dAtA[i:], m.End)
	}
	return i, nil
}

func (m *DatumInfo) 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 *DatumInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Encoding))
	dAtA[i] = 0x12
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Type.Size()))
	n6, err := m.Type.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	return i, nil
}

func (m *ProducerHeader) 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 *ProducerHeader) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintData(dAtA, i, uint64(m.FlowID.Size()))
	n7, err := m.FlowID.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	dAtA[i] = 0x10
	i++
	i = encodeVarintData(dAtA, i, uint64(m.StreamID))
	return i, nil
}

func (m *ProducerData) 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 *ProducerData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RawBytes != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintData(dAtA, i, uint64(len(m.RawBytes)))
		i += copy(dAtA[i:], m.RawBytes)
	}
	if len(m.Metadata) > 0 {
		for _, msg := range m.Metadata {
			dAtA[i] = 0x12
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x18
	i++
	i = encodeVarintData(dAtA, i, uint64(m.NumEmptyRows))
	return i, nil
}

func (m *ProducerMessage) 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 *ProducerMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintData(dAtA, i, uint64(m.Header.Size()))
		n8, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if len(m.Typing) > 0 {
		for _, msg := range m.Typing {
			dAtA[i] = 0x12
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Data.Size()))
	n9, err := m.Data.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	return i, nil
}

func (m *RemoteProducerMetadata) 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 *RemoteProducerMetadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		nn10, err := m.Value.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn10
	}
	return i, nil
}

func (m *RemoteProducerMetadata_RangeInfo) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RangeInfo != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintData(dAtA, i, uint64(m.RangeInfo.Size()))
		n11, err := m.RangeInfo.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *RemoteProducerMetadata_Error) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintData(dAtA, i, uint64(m.Error.Size()))
		n12, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}
func (m *RemoteProducerMetadata_TraceData_) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TraceData != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintData(dAtA, i, uint64(m.TraceData.Size()))
		n13, err := m.TraceData.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	return i, nil
}
func (m *RemoteProducerMetadata_RangeInfos) 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 *RemoteProducerMetadata_RangeInfos) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RangeInfo) > 0 {
		for _, msg := range m.RangeInfo {
			dAtA[i] = 0xa
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *RemoteProducerMetadata_TraceData) 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 *RemoteProducerMetadata_TraceData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.CollectedSpans) > 0 {
		for _, msg := range m.CollectedSpans {
			dAtA[i] = 0xa
			i++
			i = encodeVarintData(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *DistSQLVersionGossipInfo) 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 *DistSQLVersionGossipInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintData(dAtA, i, uint64(m.Version))
	dAtA[i] = 0x10
	i++
	i = encodeVarintData(dAtA, i, uint64(m.MinAcceptedVersion))
	return i, nil
}

func encodeFixed64Data(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Data(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintData(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 *Error) Size() (n int) {
	var l int
	_ = l
	if m.Detail != nil {
		n += m.Detail.Size()
	}
	return n
}

func (m *Error_PGError) Size() (n int) {
	var l int
	_ = l
	if m.PGError != nil {
		l = m.PGError.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *Error_RetryableTxnError) Size() (n int) {
	var l int
	_ = l
	if m.RetryableTxnError != nil {
		l = m.RetryableTxnError.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *Expression) Size() (n int) {
	var l int
	_ = l
	l = len(m.Version)
	n += 1 + l + sovData(uint64(l))
	l = len(m.Expr)
	n += 1 + l + sovData(uint64(l))
	return n
}

func (m *Ordering) Size() (n int) {
	var l int
	_ = l
	if len(m.Columns) > 0 {
		for _, e := range m.Columns {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	return n
}

func (m *Ordering_Column) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.ColIdx))
	n += 1 + sovData(uint64(m.Direction))
	return n
}

func (m *StreamEndpointSpec) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.Type))
	n += 1 + sovData(uint64(m.StreamID))
	l = len(m.TargetAddr)
	n += 1 + l + sovData(uint64(l))
	return n
}

func (m *InputSyncSpec) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.Type))
	l = m.Ordering.Size()
	n += 1 + l + sovData(uint64(l))
	if len(m.Streams) > 0 {
		for _, e := range m.Streams {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if len(m.ColumnTypes) > 0 {
		for _, e := range m.ColumnTypes {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	return n
}

func (m *OutputRouterSpec) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.Type))
	if len(m.Streams) > 0 {
		for _, e := range m.Streams {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if len(m.HashColumns) > 0 {
		for _, e := range m.HashColumns {
			n += 1 + sovData(uint64(e))
		}
	}
	l = m.RangeRouterSpec.Size()
	n += 1 + l + sovData(uint64(l))
	return n
}

func (m *OutputRouterSpec_RangeRouterSpec) Size() (n int) {
	var l int
	_ = l
	if len(m.Spans) > 0 {
		for _, e := range m.Spans {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	if m.DefaultDest != nil {
		n += 1 + sovData(uint64(*m.DefaultDest))
	}
	if len(m.Encodings) > 0 {
		for _, e := range m.Encodings {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	return n
}

func (m *OutputRouterSpec_RangeRouterSpec_ColumnEncoding) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.Column))
	n += 1 + sovData(uint64(m.Encoding))
	return n
}

func (m *OutputRouterSpec_RangeRouterSpec_Span) Size() (n int) {
	var l int
	_ = l
	if m.Start != nil {
		l = len(m.Start)
		n += 1 + l + sovData(uint64(l))
	}
	if m.End != nil {
		l = len(m.End)
		n += 1 + l + sovData(uint64(l))
	}
	return n
}

func (m *DatumInfo) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.Encoding))
	l = m.Type.Size()
	n += 1 + l + sovData(uint64(l))
	return n
}

func (m *ProducerHeader) Size() (n int) {
	var l int
	_ = l
	l = m.FlowID.Size()
	n += 1 + l + sovData(uint64(l))
	n += 1 + sovData(uint64(m.StreamID))
	return n
}

func (m *ProducerData) Size() (n int) {
	var l int
	_ = l
	if m.RawBytes != nil {
		l = len(m.RawBytes)
		n += 1 + l + sovData(uint64(l))
	}
	if len(m.Metadata) > 0 {
		for _, e := range m.Metadata {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	n += 1 + sovData(uint64(m.NumEmptyRows))
	return n
}

func (m *ProducerMessage) Size() (n int) {
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovData(uint64(l))
	}
	if len(m.Typing) > 0 {
		for _, e := range m.Typing {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	l = m.Data.Size()
	n += 1 + l + sovData(uint64(l))
	return n
}

func (m *RemoteProducerMetadata) Size() (n int) {
	var l int
	_ = l
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *RemoteProducerMetadata_RangeInfo) Size() (n int) {
	var l int
	_ = l
	if m.RangeInfo != nil {
		l = m.RangeInfo.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *RemoteProducerMetadata_Error) Size() (n int) {
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *RemoteProducerMetadata_TraceData_) Size() (n int) {
	var l int
	_ = l
	if m.TraceData != nil {
		l = m.TraceData.Size()
		n += 1 + l + sovData(uint64(l))
	}
	return n
}
func (m *RemoteProducerMetadata_RangeInfos) Size() (n int) {
	var l int
	_ = l
	if len(m.RangeInfo) > 0 {
		for _, e := range m.RangeInfo {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	return n
}

func (m *RemoteProducerMetadata_TraceData) Size() (n int) {
	var l int
	_ = l
	if len(m.CollectedSpans) > 0 {
		for _, e := range m.CollectedSpans {
			l = e.Size()
			n += 1 + l + sovData(uint64(l))
		}
	}
	return n
}

func (m *DistSQLVersionGossipInfo) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovData(uint64(m.Version))
	n += 1 + sovData(uint64(m.MinAcceptedVersion))
	return n
}

func sovData(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozData(x uint64) (n int) {
	return sovData(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Error) 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 ErrIntOverflowData
			}
			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: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PGError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &cockroach_pgerror.Error{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Detail = &Error_PGError{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetryableTxnError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &cockroach_roachpb2.UnhandledRetryableError{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Detail = &Error_RetryableTxnError{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Expression) 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 ErrIntOverflowData
			}
			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: Expression: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Expression: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Expr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Ordering) 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 ErrIntOverflowData
			}
			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: Ordering: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ordering: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Columns = append(m.Columns, Ordering_Column{})
			if err := m.Columns[len(m.Columns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Ordering_Column) 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 ErrIntOverflowData
			}
			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: Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColIdx", wireType)
			}
			m.ColIdx = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ColIdx |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType)
			}
			m.Direction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Direction |= (Ordering_Column_Direction(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StreamEndpointSpec) 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 ErrIntOverflowData
			}
			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: StreamEndpointSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamEndpointSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (StreamEndpointSpec_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType)
			}
			m.StreamID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StreamID |= (StreamID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				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 ErrInvalidLengthData
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InputSyncSpec) 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 ErrIntOverflowData
			}
			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: InputSyncSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InputSyncSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (InputSyncSpec_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ordering", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Ordering.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Streams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Streams = append(m.Streams, StreamEndpointSpec{})
			if err := m.Streams[len(m.Streams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnTypes = append(m.ColumnTypes, cockroach_sql_sqlbase1.ColumnType{})
			if err := m.ColumnTypes[len(m.ColumnTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutputRouterSpec) 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 ErrIntOverflowData
			}
			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: OutputRouterSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutputRouterSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (OutputRouterSpec_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Streams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Streams = append(m.Streams, StreamEndpointSpec{})
			if err := m.Streams[len(m.Streams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowData
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint32(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.HashColumns = append(m.HashColumns, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowData
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthData
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowData
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.HashColumns = append(m.HashColumns, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field HashColumns", wireType)
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeRouterSpec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RangeRouterSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutputRouterSpec_RangeRouterSpec) 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 ErrIntOverflowData
			}
			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: RangeRouterSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RangeRouterSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Spans = append(m.Spans, OutputRouterSpec_RangeRouterSpec_Span{})
			if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultDest", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DefaultDest = &v
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encodings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Encodings = append(m.Encodings, OutputRouterSpec_RangeRouterSpec_ColumnEncoding{})
			if err := m.Encodings[len(m.Encodings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutputRouterSpec_RangeRouterSpec_ColumnEncoding) 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 ErrIntOverflowData
			}
			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: ColumnEncoding: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnEncoding: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType)
			}
			m.Column = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Column |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encoding", wireType)
			}
			m.Encoding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Encoding |= (cockroach_sql_sqlbase2.DatumEncoding(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutputRouterSpec_RangeRouterSpec_Span) 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 ErrIntOverflowData
			}
			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: Span: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Span: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Start = append(m.Start[:0], dAtA[iNdEx:postIndex]...)
			if m.Start == nil {
				m.Start = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.End = append(m.End[:0], dAtA[iNdEx:postIndex]...)
			if m.End == nil {
				m.End = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DatumInfo) 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 ErrIntOverflowData
			}
			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: DatumInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatumInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encoding", wireType)
			}
			m.Encoding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Encoding |= (cockroach_sql_sqlbase2.DatumEncoding(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Type.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProducerHeader) 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 ErrIntOverflowData
			}
			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: ProducerHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProducerHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlowID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FlowID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamID", wireType)
			}
			m.StreamID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StreamID |= (StreamID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProducerData) 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 ErrIntOverflowData
			}
			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: ProducerData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProducerData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RawBytes = append(m.RawBytes[:0], dAtA[iNdEx:postIndex]...)
			if m.RawBytes == nil {
				m.RawBytes = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata, RemoteProducerMetadata{})
			if err := m.Metadata[len(m.Metadata)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumEmptyRows", wireType)
			}
			m.NumEmptyRows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumEmptyRows |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProducerMessage) 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 ErrIntOverflowData
			}
			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: ProducerMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProducerMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &ProducerHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typing", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Typing = append(m.Typing, DatumInfo{})
			if err := m.Typing[len(m.Typing)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoteProducerMetadata) 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 ErrIntOverflowData
			}
			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: RemoteProducerMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoteProducerMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RemoteProducerMetadata_RangeInfos{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &RemoteProducerMetadata_RangeInfo{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &RemoteProducerMetadata_Error{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RemoteProducerMetadata_TraceData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &RemoteProducerMetadata_TraceData_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoteProducerMetadata_RangeInfos) 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 ErrIntOverflowData
			}
			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: RangeInfos: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RangeInfos: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RangeInfo = append(m.RangeInfo, cockroach_roachpb3.RangeInfo{})
			if err := m.RangeInfo[len(m.RangeInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoteProducerMetadata_TraceData) 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 ErrIntOverflowData
			}
			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: TraceData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TraceData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectedSpans", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthData
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CollectedSpans = append(m.CollectedSpans, cockroach_util_tracing.RecordedSpan{})
			if err := m.CollectedSpans[len(m.CollectedSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DistSQLVersionGossipInfo) 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 ErrIntOverflowData
			}
			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: DistSQLVersionGossipInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DistSQLVersionGossipInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= (DistSQLVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinAcceptedVersion", wireType)
			}
			m.MinAcceptedVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinAcceptedVersion |= (DistSQLVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipData(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, ErrIntOverflowData
			}
			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, ErrIntOverflowData
				}
				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, ErrIntOverflowData
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthData
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowData
					}
					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 := skipData(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			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 (
	ErrInvalidLengthData = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowData   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("cockroach/pkg/sql/distsqlrun/data.proto", fileDescriptorData) }

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