types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: types.proto

package functionAgg

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_matrixorigin_matrixone_pkg_container_types "github.com/matrixorigin/matrixone/pkg/container/types"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

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

var xxx_messageInfo_EncodeVariance proto.InternalMessageInfo

func (m *EncodeVariance) GetSum() []float64 {
	if m != nil {
		return m.Sum
	}
	return nil
}

func (m *EncodeVariance) GetCounts() []float64 {
	if m != nil {
		return m.Counts
	}
	return nil
}

type EncodeDecimalV struct {
	Sum    []github_com_matrixorigin_matrixone_pkg_container_types.Decimal128 `protobuf:"bytes,1,rep,name=sum,proto3,customtype=github.com/matrixorigin/matrixone/pkg/container/types.Decimal128" json:"sum,omitempty"`
	Counts []int64                                                            `protobuf:"varint,2,rep,packed,name=Counts,proto3" json:"Counts,omitempty"`
	ErrOne []bool                                                             `protobuf:"varint,3,rep,packed,name=ErrOne,proto3" json:"ErrOne,omitempty"`
}

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

var xxx_messageInfo_EncodeDecimalV proto.InternalMessageInfo

func (m *EncodeDecimalV) GetCounts() []int64 {
	if m != nil {
		return m.Counts
	}
	return nil
}

func (m *EncodeDecimalV) GetErrOne() []bool {
	if m != nil {
		return m.ErrOne
	}
	return nil
}

type VariancePB struct {
	Sum    []float64 `protobuf:"fixed64,1,rep,packed,name=Sum,proto3" json:"Sum,omitempty"`
	Counts []float64 `protobuf:"fixed64,2,rep,packed,name=Counts,proto3" json:"Counts,omitempty"`
}

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

var xxx_messageInfo_VariancePB proto.InternalMessageInfo

func (m *VariancePB) GetSum() []float64 {
	if m != nil {
		return m.Sum
	}
	return nil
}

func (m *VariancePB) GetCounts() []float64 {
	if m != nil {
		return m.Counts
	}
	return nil
}

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

var xxx_messageInfo_VarianceDecimal proto.InternalMessageInfo

func (m *VarianceDecimal) GetCounts() []int64 {
	if m != nil {
		return m.Counts
	}
	return nil
}

func (m *VarianceDecimal) GetScaleMul() int32 {
	if m != nil {
		return m.ScaleMul
	}
	return 0
}

func (m *VarianceDecimal) GetScaleDiv() int32 {
	if m != nil {
		return m.ScaleDiv
	}
	return 0
}

func (m *VarianceDecimal) GetScaleMulDiv() int32 {
	if m != nil {
		return m.ScaleMulDiv
	}
	return 0
}

func (m *VarianceDecimal) GetScaleDivMul() int32 {
	if m != nil {
		return m.ScaleDivMul
	}
	return 0
}

func (m *VarianceDecimal) GetErrOne() []bool {
	if m != nil {
		return m.ErrOne
	}
	return nil
}

type Decimal64SlicePB struct {
	Slice []github_com_matrixorigin_matrixone_pkg_container_types.Decimal64 `protobuf:"bytes,1,rep,name=Slice,proto3,customtype=github.com/matrixorigin/matrixone/pkg/container/types.Decimal64" json:"Slice"`
}

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

var xxx_messageInfo_Decimal64SlicePB proto.InternalMessageInfo

type Decimal128SlicePB struct {
	Slice []github_com_matrixorigin_matrixone_pkg_container_types.Decimal128 `protobuf:"bytes,1,rep,name=Slice,proto3,customtype=github.com/matrixorigin/matrixone/pkg/container/types.Decimal128" json:"Slice"`
}

func (m *Decimal128SlicePB) Reset()         { *m = Decimal128SlicePB{} }
func (m *Decimal128SlicePB) String() string { return proto.CompactTextString(m) }
func (*Decimal128SlicePB) ProtoMessage()    {}
func (*Decimal128SlicePB) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{5}
}
func (m *Decimal128SlicePB) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Decimal128SlicePB) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Decimal128SlicePB.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Decimal128SlicePB) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Decimal128SlicePB.Merge(m, src)
}
func (m *Decimal128SlicePB) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Decimal128SlicePB) XXX_DiscardUnknown() {
	xxx_messageInfo_Decimal128SlicePB.DiscardUnknown(m)
}

var xxx_messageInfo_Decimal128SlicePB proto.InternalMessageInfo

type Decimal64Median struct {
	Vals []decimal64Slice `protobuf:"bytes,1,rep,name=Vals,proto3,customtype=decimal64Slice" json:"Vals"`
}

func (m *Decimal64Median) Reset()         { *m = Decimal64Median{} }
func (m *Decimal64Median) String() string { return proto.CompactTextString(m) }
func (*Decimal64Median) ProtoMessage()    {}
func (*Decimal64Median) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{6}
}
func (m *Decimal64Median) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Decimal64Median) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Decimal64Median.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Decimal64Median) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Decimal64Median.Merge(m, src)
}
func (m *Decimal64Median) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Decimal64Median) XXX_DiscardUnknown() {
	xxx_messageInfo_Decimal64Median.DiscardUnknown(m)
}

var xxx_messageInfo_Decimal64Median proto.InternalMessageInfo

type Decimal128Median struct {
	Vals []decimal128Slice `protobuf:"bytes,1,rep,name=Vals,proto3,customtype=decimal128Slice" json:"Vals"`
}

func (m *Decimal128Median) Reset()         { *m = Decimal128Median{} }
func (m *Decimal128Median) String() string { return proto.CompactTextString(m) }
func (*Decimal128Median) ProtoMessage()    {}
func (*Decimal128Median) Descriptor() ([]byte, []int) {
	return fileDescriptor_d938547f84707355, []int{7}
}
func (m *Decimal128Median) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Decimal128Median) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Decimal128Median.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Decimal128Median) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Decimal128Median.Merge(m, src)
}
func (m *Decimal128Median) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Decimal128Median) XXX_DiscardUnknown() {
	xxx_messageInfo_Decimal128Median.DiscardUnknown(m)
}

var xxx_messageInfo_Decimal128Median proto.InternalMessageInfo

func init() {
	proto.RegisterType((*EncodeVariance)(nil), "functionAgg.EncodeVariance")
	proto.RegisterType((*EncodeDecimalV)(nil), "functionAgg.EncodeDecimalV")
	proto.RegisterType((*VariancePB)(nil), "functionAgg.VariancePB")
	proto.RegisterType((*VarianceDecimal)(nil), "functionAgg.VarianceDecimal")
	proto.RegisterType((*Decimal64SlicePB)(nil), "functionAgg.Decimal64SlicePB")
	proto.RegisterType((*Decimal128SlicePB)(nil), "functionAgg.Decimal128SlicePB")
	proto.RegisterType((*Decimal64Median)(nil), "functionAgg.Decimal64Median")
	proto.RegisterType((*Decimal128Median)(nil), "functionAgg.Decimal128Median")
}

func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) }

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

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

func (m *EncodeVariance) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EncodeVariance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Counts) > 0 {
		for iNdEx := len(m.Counts) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float64bits(float64(m.Counts[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Counts)*8))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sum) > 0 {
		for iNdEx := len(m.Sum) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float64bits(float64(m.Sum[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f2))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sum)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EncodeDecimalV) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EncodeDecimalV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ErrOne) > 0 {
		for iNdEx := len(m.ErrOne) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.ErrOne[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ErrOne)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Counts) > 0 {
		dAtA4 := make([]byte, len(m.Counts)*10)
		var j3 int
		for _, num1 := range m.Counts {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintTypes(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sum) > 0 {
		for iNdEx := len(m.Sum) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Sum[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Sum[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *VariancePB) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VariancePB) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Counts) > 0 {
		for iNdEx := len(m.Counts) - 1; iNdEx >= 0; iNdEx-- {
			f5 := math.Float64bits(float64(m.Counts[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f5))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Counts)*8))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sum) > 0 {
		for iNdEx := len(m.Sum) - 1; iNdEx >= 0; iNdEx-- {
			f6 := math.Float64bits(float64(m.Sum[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f6))
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sum)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *VarianceDecimal) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VarianceDecimal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ErrOne) > 0 {
		for iNdEx := len(m.ErrOne) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.ErrOne[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ErrOne)))
		i--
		dAtA[i] = 0x42
	}
	if m.ScaleDivMul != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ScaleDivMul))
		i--
		dAtA[i] = 0x38
	}
	if m.ScaleMulDiv != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ScaleMulDiv))
		i--
		dAtA[i] = 0x30
	}
	if m.ScaleDiv != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ScaleDiv))
		i--
		dAtA[i] = 0x28
	}
	if m.ScaleMul != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ScaleMul))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.Typ.ProtoSize()
		i -= size
		if _, err := m.Typ.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Counts) > 0 {
		dAtA8 := make([]byte, len(m.Counts)*10)
		var j7 int
		for _, num1 := range m.Counts {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintTypes(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sum) > 0 {
		for iNdEx := len(m.Sum) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Sum[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Sum[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Decimal64SlicePB) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Decimal64SlicePB) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Slice) > 0 {
		for iNdEx := len(m.Slice) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Slice[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Slice[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Decimal128SlicePB) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Decimal128SlicePB) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Slice) > 0 {
		for iNdEx := len(m.Slice) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Slice[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Slice[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Decimal64Median) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Decimal64Median) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Vals) > 0 {
		for iNdEx := len(m.Vals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Vals[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Vals[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Decimal128Median) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Decimal128Median) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Vals) > 0 {
		for iNdEx := len(m.Vals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Vals[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Vals[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EncodeVariance) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Sum) > 0 {
		n += 1 + sovTypes(uint64(len(m.Sum)*8)) + len(m.Sum)*8
	}
	if len(m.Counts) > 0 {
		n += 1 + sovTypes(uint64(len(m.Counts)*8)) + len(m.Counts)*8
	}
	return n
}

func (m *EncodeDecimalV) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Sum) > 0 {
		for _, e := range m.Sum {
			l = e.ProtoSize()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Counts) > 0 {
		l = 0
		for _, e := range m.Counts {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	if len(m.ErrOne) > 0 {
		n += 1 + sovTypes(uint64(len(m.ErrOne))) + len(m.ErrOne)*1
	}
	return n
}

func (m *VariancePB) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Sum) > 0 {
		n += 1 + sovTypes(uint64(len(m.Sum)*8)) + len(m.Sum)*8
	}
	if len(m.Counts) > 0 {
		n += 1 + sovTypes(uint64(len(m.Counts)*8)) + len(m.Counts)*8
	}
	return n
}

func (m *VarianceDecimal) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Sum) > 0 {
		for _, e := range m.Sum {
			l = e.ProtoSize()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Counts) > 0 {
		l = 0
		for _, e := range m.Counts {
			l += sovTypes(uint64(e))
		}
		n += 1 + sovTypes(uint64(l)) + l
	}
	l = m.Typ.ProtoSize()
	n += 1 + l + sovTypes(uint64(l))
	if m.ScaleMul != 0 {
		n += 1 + sovTypes(uint64(m.ScaleMul))
	}
	if m.ScaleDiv != 0 {
		n += 1 + sovTypes(uint64(m.ScaleDiv))
	}
	if m.ScaleMulDiv != 0 {
		n += 1 + sovTypes(uint64(m.ScaleMulDiv))
	}
	if m.ScaleDivMul != 0 {
		n += 1 + sovTypes(uint64(m.ScaleDivMul))
	}
	if len(m.ErrOne) > 0 {
		n += 1 + sovTypes(uint64(len(m.ErrOne))) + len(m.ErrOne)*1
	}
	return n
}

func (m *Decimal64SlicePB) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Slice) > 0 {
		for _, e := range m.Slice {
			l = e.ProtoSize()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *Decimal128SlicePB) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Slice) > 0 {
		for _, e := range m.Slice {
			l = e.ProtoSize()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *Decimal64Median) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Vals) > 0 {
		for _, e := range m.Vals {
			l = e.ProtoSize()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *Decimal128Median) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Vals) > 0 {
		for _, e := range m.Vals {
			l = e.ProtoSize()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EncodeVariance) 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 ErrIntOverflowTypes
			}
			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: EncodeVariance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EncodeVariance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Sum = append(m.Sum, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Sum) == 0 {
					m.Sum = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Sum = append(m.Sum, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
		case 2:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Counts = append(m.Counts, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Counts) == 0 {
					m.Counts = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Counts = append(m.Counts, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Counts", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EncodeDecimalV) 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 ErrIntOverflowTypes
			}
			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: EncodeDecimalV: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EncodeDecimalV: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_matrixorigin_matrixone_pkg_container_types.Decimal128
			m.Sum = append(m.Sum, v)
			if err := m.Sum[len(m.Sum)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Counts = append(m.Counts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Counts) == 0 {
					m.Counts = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Counts = append(m.Counts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Counts", wireType)
			}
		case 3:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ErrOne = append(m.ErrOne, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.ErrOne) == 0 {
					m.ErrOne = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ErrOne = append(m.ErrOne, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrOne", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VariancePB) 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 ErrIntOverflowTypes
			}
			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: VariancePB: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VariancePB: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Sum = append(m.Sum, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Sum) == 0 {
					m.Sum = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Sum = append(m.Sum, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
		case 2:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Counts = append(m.Counts, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Counts) == 0 {
					m.Counts = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Counts = append(m.Counts, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Counts", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VarianceDecimal) 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 ErrIntOverflowTypes
			}
			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: VarianceDecimal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VarianceDecimal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_matrixorigin_matrixone_pkg_container_types.Decimal128
			m.Sum = append(m.Sum, v)
			if err := m.Sum[len(m.Sum)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Counts = append(m.Counts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Counts) == 0 {
					m.Counts = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Counts = append(m.Counts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Counts", wireType)
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Typ.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleMul", wireType)
			}
			m.ScaleMul = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScaleMul |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDiv", wireType)
			}
			m.ScaleDiv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScaleDiv |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleMulDiv", wireType)
			}
			m.ScaleMulDiv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScaleMulDiv |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScaleDivMul", wireType)
			}
			m.ScaleDivMul = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScaleDivMul |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ErrOne = append(m.ErrOne, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTypes
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTypes
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTypes
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.ErrOne) == 0 {
					m.ErrOne = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTypes
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ErrOne = append(m.ErrOne, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrOne", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTypes
			}
			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, ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)