github.com/GuanceCloud/cliutils@v1.1.21/point/gogopb/point.pb.go

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

package gogopb

import (
	bytes "bytes"
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

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

type KeyType int32

const (
	X   KeyType = 0
	I   KeyType = 1
	U   KeyType = 2
	F   KeyType = 3
	B   KeyType = 4
	D   KeyType = 5
	NIL KeyType = 6
	S   KeyType = 7
	A   KeyType = 8
)

var KeyType_name = map[int32]string{
	0: "X",
	1: "I",
	2: "U",
	3: "F",
	4: "B",
	5: "D",
	6: "NIL",
	7: "S",
	8: "A",
}

var KeyType_value = map[string]int32{
	"X":   0,
	"I":   1,
	"U":   2,
	"F":   3,
	"B":   4,
	"D":   5,
	"NIL": 6,
	"S":   7,
	"A":   8,
}

func (KeyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{0}
}

type MetricType int32

const (
	UNSPECIFIED MetricType = 0
	COUNT       MetricType = 1
	RATE        MetricType = 2
	GAUGE       MetricType = 3
)

var MetricType_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "COUNT",
	2: "RATE",
	3: "GAUGE",
}

var MetricType_value = map[string]int32{
	"UNSPECIFIED": 0,
	"COUNT":       1,
	"RATE":        2,
	"GAUGE":       3,
}

func (MetricType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{1}
}

// Debug used to attached some debug info for the point, these debug info
// will encoded into payload, storage can take optional handle on these debug
// info.
type Debug struct {
	Info string `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
}

func (m *Debug) Reset()      { *m = Debug{} }
func (*Debug) ProtoMessage() {}
func (*Debug) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{0}
}
func (m *Debug) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Debug) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Debug.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 *Debug) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Debug.Merge(m, src)
}
func (m *Debug) XXX_Size() int {
	return m.Size()
}
func (m *Debug) XXX_DiscardUnknown() {
	xxx_messageInfo_Debug.DiscardUnknown(m)
}

var xxx_messageInfo_Debug proto.InternalMessageInfo

func (m *Debug) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

// example of pb.Any
type AnyDemo struct {
	Demo string `protobuf:"bytes,1,opt,name=demo,proto3" json:"demo,omitempty"`
}

func (m *AnyDemo) Reset()      { *m = AnyDemo{} }
func (*AnyDemo) ProtoMessage() {}
func (*AnyDemo) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{1}
}
func (m *AnyDemo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AnyDemo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AnyDemo.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 *AnyDemo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnyDemo.Merge(m, src)
}
func (m *AnyDemo) XXX_Size() int {
	return m.Size()
}
func (m *AnyDemo) XXX_DiscardUnknown() {
	xxx_messageInfo_AnyDemo.DiscardUnknown(m)
}

var xxx_messageInfo_AnyDemo proto.InternalMessageInfo

func (m *AnyDemo) GetDemo() string {
	if m != nil {
		return m.Demo
	}
	return ""
}

type BasicTypes struct {
	// Types that are valid to be assigned to X:
	//	*BasicTypes_I
	//	*BasicTypes_U
	//	*BasicTypes_F
	//	*BasicTypes_B
	//	*BasicTypes_D
	//	*BasicTypes_S
	X isBasicTypes_X `protobuf_oneof:"x"`
}

func (m *BasicTypes) Reset()      { *m = BasicTypes{} }
func (*BasicTypes) ProtoMessage() {}
func (*BasicTypes) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{2}
}
func (m *BasicTypes) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BasicTypes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BasicTypes.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 *BasicTypes) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BasicTypes.Merge(m, src)
}
func (m *BasicTypes) XXX_Size() int {
	return m.Size()
}
func (m *BasicTypes) XXX_DiscardUnknown() {
	xxx_messageInfo_BasicTypes.DiscardUnknown(m)
}

var xxx_messageInfo_BasicTypes proto.InternalMessageInfo

type isBasicTypes_X interface {
	isBasicTypes_X()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type BasicTypes_I struct {
	I int64 `protobuf:"varint,1,opt,name=i,proto3,oneof" json:"i,omitempty"`
}
type BasicTypes_U struct {
	U uint64 `protobuf:"varint,2,opt,name=u,proto3,oneof" json:"u,omitempty"`
}
type BasicTypes_F struct {
	F float64 `protobuf:"fixed64,3,opt,name=f,proto3,oneof" json:"f,omitempty"`
}
type BasicTypes_B struct {
	B bool `protobuf:"varint,4,opt,name=b,proto3,oneof" json:"b,omitempty"`
}
type BasicTypes_D struct {
	D []byte `protobuf:"bytes,5,opt,name=d,proto3,oneof" json:"d,omitempty"`
}
type BasicTypes_S struct {
	S string `protobuf:"bytes,6,opt,name=s,proto3,oneof" json:"s,omitempty"`
}

func (*BasicTypes_I) isBasicTypes_X() {}
func (*BasicTypes_U) isBasicTypes_X() {}
func (*BasicTypes_F) isBasicTypes_X() {}
func (*BasicTypes_B) isBasicTypes_X() {}
func (*BasicTypes_D) isBasicTypes_X() {}
func (*BasicTypes_S) isBasicTypes_X() {}

func (m *BasicTypes) GetX() isBasicTypes_X {
	if m != nil {
		return m.X
	}
	return nil
}

func (m *BasicTypes) GetI() int64 {
	if x, ok := m.GetX().(*BasicTypes_I); ok {
		return x.I
	}
	return 0
}

func (m *BasicTypes) GetU() uint64 {
	if x, ok := m.GetX().(*BasicTypes_U); ok {
		return x.U
	}
	return 0
}

func (m *BasicTypes) GetF() float64 {
	if x, ok := m.GetX().(*BasicTypes_F); ok {
		return x.F
	}
	return 0
}

func (m *BasicTypes) GetB() bool {
	if x, ok := m.GetX().(*BasicTypes_B); ok {
		return x.B
	}
	return false
}

func (m *BasicTypes) GetD() []byte {
	if x, ok := m.GetX().(*BasicTypes_D); ok {
		return x.D
	}
	return nil
}

func (m *BasicTypes) GetS() string {
	if x, ok := m.GetX().(*BasicTypes_S); ok {
		return x.S
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BasicTypes) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BasicTypes_I)(nil),
		(*BasicTypes_U)(nil),
		(*BasicTypes_F)(nil),
		(*BasicTypes_B)(nil),
		(*BasicTypes_D)(nil),
		(*BasicTypes_S)(nil),
	}
}

type Array struct {
	Arr []*BasicTypes `protobuf:"bytes,1,rep,name=arr,proto3" json:"arr,omitempty"`
}

func (m *Array) Reset()      { *m = Array{} }
func (*Array) ProtoMessage() {}
func (*Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{3}
}
func (m *Array) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Array.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 *Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Array.Merge(m, src)
}
func (m *Array) XXX_Size() int {
	return m.Size()
}
func (m *Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Array.DiscardUnknown(m)
}

var xxx_messageInfo_Array proto.InternalMessageInfo

func (m *Array) GetArr() []*BasicTypes {
	if m != nil {
		return m.Arr
	}
	return nil
}

type Map struct {
	Map map[string]*BasicTypes `protobuf:"bytes,1,rep,name=map,proto3" json:"map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *Map) Reset()      { *m = Map{} }
func (*Map) ProtoMessage() {}
func (*Map) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{4}
}
func (m *Map) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Map) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Map.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 *Map) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Map.Merge(m, src)
}
func (m *Map) XXX_Size() int {
	return m.Size()
}
func (m *Map) XXX_DiscardUnknown() {
	xxx_messageInfo_Map.DiscardUnknown(m)
}

var xxx_messageInfo_Map proto.InternalMessageInfo

func (m *Map) GetMap() map[string]*BasicTypes {
	if m != nil {
		return m.Map
	}
	return nil
}

type Field struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// See https://developers.google.com/protocol-buffers/docs/proto3#json
	//
	// Types that are valid to be assigned to Val:
	//	*Field_I
	//	*Field_U
	//	*Field_F
	//	*Field_B
	//	*Field_D
	//	*Field_S
	//	*Field_A
	Val   isField_Val `protobuf_oneof:"val"`
	IsTag bool        `protobuf:"varint,8,opt,name=is_tag,proto3" json:"is_tag,omitempty"`
	Type  MetricType  `protobuf:"varint,9,opt,name=type,proto3,enum=gogopb.MetricType" json:"type,omitempty"`
	// field unit name
	Unit string `protobuf:"bytes,10,opt,name=unit,proto3" json:"unit,omitempty"`
}

func (m *Field) Reset()      { *m = Field{} }
func (*Field) ProtoMessage() {}
func (*Field) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{5}
}
func (m *Field) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Field) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Field.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 *Field) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Field.Merge(m, src)
}
func (m *Field) XXX_Size() int {
	return m.Size()
}
func (m *Field) XXX_DiscardUnknown() {
	xxx_messageInfo_Field.DiscardUnknown(m)
}

var xxx_messageInfo_Field proto.InternalMessageInfo

type isField_Val interface {
	isField_Val()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Field_I struct {
	I int64 `protobuf:"varint,2,opt,name=i,proto3,oneof" json:"i,omitempty"`
}
type Field_U struct {
	U uint64 `protobuf:"varint,3,opt,name=u,proto3,oneof" json:"u,omitempty"`
}
type Field_F struct {
	F float64 `protobuf:"fixed64,4,opt,name=f,proto3,oneof" json:"f,omitempty"`
}
type Field_B struct {
	B bool `protobuf:"varint,5,opt,name=b,proto3,oneof" json:"b,omitempty"`
}
type Field_D struct {
	D []byte `protobuf:"bytes,6,opt,name=d,proto3,oneof" json:"d,omitempty"`
}
type Field_S struct {
	S string `protobuf:"bytes,11,opt,name=s,proto3,oneof" json:"s,omitempty"`
}
type Field_A struct {
	A *types.Any `protobuf:"bytes,7,opt,name=a,proto3,oneof" json:"a,omitempty"`
}

func (*Field_I) isField_Val() {}
func (*Field_U) isField_Val() {}
func (*Field_F) isField_Val() {}
func (*Field_B) isField_Val() {}
func (*Field_D) isField_Val() {}
func (*Field_S) isField_Val() {}
func (*Field_A) isField_Val() {}

func (m *Field) GetVal() isField_Val {
	if m != nil {
		return m.Val
	}
	return nil
}

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

func (m *Field) GetI() int64 {
	if x, ok := m.GetVal().(*Field_I); ok {
		return x.I
	}
	return 0
}

func (m *Field) GetU() uint64 {
	if x, ok := m.GetVal().(*Field_U); ok {
		return x.U
	}
	return 0
}

func (m *Field) GetF() float64 {
	if x, ok := m.GetVal().(*Field_F); ok {
		return x.F
	}
	return 0
}

func (m *Field) GetB() bool {
	if x, ok := m.GetVal().(*Field_B); ok {
		return x.B
	}
	return false
}

func (m *Field) GetD() []byte {
	if x, ok := m.GetVal().(*Field_D); ok {
		return x.D
	}
	return nil
}

func (m *Field) GetS() string {
	if x, ok := m.GetVal().(*Field_S); ok {
		return x.S
	}
	return ""
}

func (m *Field) GetA() *types.Any {
	if x, ok := m.GetVal().(*Field_A); ok {
		return x.A
	}
	return nil
}

func (m *Field) GetIsTag() bool {
	if m != nil {
		return m.IsTag
	}
	return false
}

func (m *Field) GetType() MetricType {
	if m != nil {
		return m.Type
	}
	return UNSPECIFIED
}

func (m *Field) GetUnit() string {
	if m != nil {
		return m.Unit
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Field) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Field_I)(nil),
		(*Field_U)(nil),
		(*Field_F)(nil),
		(*Field_B)(nil),
		(*Field_D)(nil),
		(*Field_S)(nil),
		(*Field_A)(nil),
	}
}

// Warn used to attach some warning message during building the point.
type Warn struct {
	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Msg  string `protobuf:"bytes,2,opt,name=msg,json=message,proto3" json:"msg,omitempty"`
}

func (m *Warn) Reset()      { *m = Warn{} }
func (*Warn) ProtoMessage() {}
func (*Warn) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{6}
}
func (m *Warn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Warn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Warn.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 *Warn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Warn.Merge(m, src)
}
func (m *Warn) XXX_Size() int {
	return m.Size()
}
func (m *Warn) XXX_DiscardUnknown() {
	xxx_messageInfo_Warn.DiscardUnknown(m)
}

var xxx_messageInfo_Warn proto.InternalMessageInfo

func (m *Warn) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *Warn) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

type PBPoint struct {
	Name   string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Fields []*Field `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
	Time   int64    `protobuf:"varint,3,opt,name=time,proto3" json:"time,omitempty"`
	// Auxiliary fields for the point, they should not
	// write to the final storage on production.
	Warns  []*Warn  `protobuf:"bytes,4,rep,name=warns,proto3" json:"warns,omitempty"`
	Debugs []*Debug `protobuf:"bytes,5,rep,name=debugs,proto3" json:"debugs,omitempty"`
}

func (m *PBPoint) Reset()      { *m = PBPoint{} }
func (*PBPoint) ProtoMessage() {}
func (*PBPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{7}
}
func (m *PBPoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PBPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PBPoint.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 *PBPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PBPoint.Merge(m, src)
}
func (m *PBPoint) XXX_Size() int {
	return m.Size()
}
func (m *PBPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_PBPoint.DiscardUnknown(m)
}

var xxx_messageInfo_PBPoint proto.InternalMessageInfo

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

func (m *PBPoint) GetFields() []*Field {
	if m != nil {
		return m.Fields
	}
	return nil
}

func (m *PBPoint) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *PBPoint) GetWarns() []*Warn {
	if m != nil {
		return m.Warns
	}
	return nil
}

func (m *PBPoint) GetDebugs() []*Debug {
	if m != nil {
		return m.Debugs
	}
	return nil
}

// batch of pbpoint.
type PBPoints struct {
	Arr []*PBPoint `protobuf:"bytes,1,rep,name=arr,proto3" json:"arr,omitempty"`
}

func (m *PBPoints) Reset()      { *m = PBPoints{} }
func (*PBPoints) ProtoMessage() {}
func (*PBPoints) Descriptor() ([]byte, []int) {
	return fileDescriptor_dbb1a16d5866e018, []int{8}
}
func (m *PBPoints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PBPoints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PBPoints.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 *PBPoints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PBPoints.Merge(m, src)
}
func (m *PBPoints) XXX_Size() int {
	return m.Size()
}
func (m *PBPoints) XXX_DiscardUnknown() {
	xxx_messageInfo_PBPoints.DiscardUnknown(m)
}

var xxx_messageInfo_PBPoints proto.InternalMessageInfo

func (m *PBPoints) GetArr() []*PBPoint {
	if m != nil {
		return m.Arr
	}
	return nil
}

func init() {
	proto.RegisterEnum("gogopb.KeyType", KeyType_name, KeyType_value)
	proto.RegisterEnum("gogopb.MetricType", MetricType_name, MetricType_value)
	proto.RegisterType((*Debug)(nil), "gogopb.Debug")
	proto.RegisterType((*AnyDemo)(nil), "gogopb.AnyDemo")
	proto.RegisterType((*BasicTypes)(nil), "gogopb.BasicTypes")
	proto.RegisterType((*Array)(nil), "gogopb.Array")
	proto.RegisterType((*Map)(nil), "gogopb.Map")
	proto.RegisterMapType((map[string]*BasicTypes)(nil), "gogopb.Map.MapEntry")
	proto.RegisterType((*Field)(nil), "gogopb.Field")
	proto.RegisterType((*Warn)(nil), "gogopb.Warn")
	proto.RegisterType((*PBPoint)(nil), "gogopb.PBPoint")
	proto.RegisterType((*PBPoints)(nil), "gogopb.PBPoints")
}

func init() { proto.RegisterFile("point.proto", fileDescriptor_dbb1a16d5866e018) }

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

func (x KeyType) String() string {
	s, ok := KeyType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x MetricType) String() string {
	s, ok := MetricType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Debug) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Debug)
	if !ok {
		that2, ok := that.(Debug)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Info != that1.Info {
		return false
	}
	return true
}
func (this *AnyDemo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AnyDemo)
	if !ok {
		that2, ok := that.(AnyDemo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Demo != that1.Demo {
		return false
	}
	return true
}
func (this *BasicTypes) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BasicTypes)
	if !ok {
		that2, ok := that.(BasicTypes)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.X == nil {
		if this.X != nil {
			return false
		}
	} else if this.X == nil {
		return false
	} else if !this.X.Equal(that1.X) {
		return false
	}
	return true
}
func (this *BasicTypes_I) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BasicTypes_I)
	if !ok {
		that2, ok := that.(BasicTypes_I)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.I != that1.I {
		return false
	}
	return true
}
func (this *BasicTypes_U) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BasicTypes_U)
	if !ok {
		that2, ok := that.(BasicTypes_U)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.U != that1.U {
		return false
	}
	return true
}
func (this *BasicTypes_F) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BasicTypes_F)
	if !ok {
		that2, ok := that.(BasicTypes_F)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.F != that1.F {
		return false
	}
	return true
}
func (this *BasicTypes_B) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BasicTypes_B)
	if !ok {
		that2, ok := that.(BasicTypes_B)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.B != that1.B {
		return false
	}
	return true
}
func (this *BasicTypes_D) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*BasicTypes_S)
	if !ok {
		that2, ok := that.(BasicTypes_S)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.S != that1.S {
		return false
	}
	return true
}
func (this *Array) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Array)
	if !ok {
		that2, ok := that.(Array)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Arr) != len(that1.Arr) {
		return false
	}
	for i := range this.Arr {
		if !this.Arr[i].Equal(that1.Arr[i]) {
			return false
		}
	}
	return true
}
func (this *Map) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Map)
	if !ok {
		that2, ok := that.(Map)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Map) != len(that1.Map) {
		return false
	}
	for i := range this.Map {
		if !this.Map[i].Equal(that1.Map[i]) {
			return false
		}
	}
	return true
}
func (this *Field) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Field)
	if !ok {
		that2, ok := that.(Field)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if that1.Val == nil {
		if this.Val != nil {
			return false
		}
	} else if this.Val == nil {
		return false
	} else if !this.Val.Equal(that1.Val) {
		return false
	}
	if this.IsTag != that1.IsTag {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Unit != that1.Unit {
		return false
	}
	return true
}
func (this *Field_I) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Field_I)
	if !ok {
		that2, ok := that.(Field_I)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.I != that1.I {
		return false
	}
	return true
}
func (this *Field_U) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Field_U)
	if !ok {
		that2, ok := that.(Field_U)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.U != that1.U {
		return false
	}
	return true
}
func (this *Field_F) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Field_F)
	if !ok {
		that2, ok := that.(Field_F)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.F != that1.F {
		return false
	}
	return true
}
func (this *Field_B) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Field_B)
	if !ok {
		that2, ok := that.(Field_B)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.B != that1.B {
		return false
	}
	return true
}
func (this *Field_D) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*Field_S)
	if !ok {
		that2, ok := that.(Field_S)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.S != that1.S {
		return false
	}
	return true
}
func (this *Field_A) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Field_A)
	if !ok {
		that2, ok := that.(Field_A)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.A.Equal(that1.A) {
		return false
	}
	return true
}
func (this *Warn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Warn)
	if !ok {
		that2, ok := that.(Warn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Msg != that1.Msg {
		return false
	}
	return true
}
func (this *PBPoint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PBPoint)
	if !ok {
		that2, ok := that.(PBPoint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.Fields) != len(that1.Fields) {
		return false
	}
	for i := range this.Fields {
		if !this.Fields[i].Equal(that1.Fields[i]) {
			return false
		}
	}
	if this.Time != that1.Time {
		return false
	}
	if len(this.Warns) != len(that1.Warns) {
		return false
	}
	for i := range this.Warns {
		if !this.Warns[i].Equal(that1.Warns[i]) {
			return false
		}
	}
	if len(this.Debugs) != len(that1.Debugs) {
		return false
	}
	for i := range this.Debugs {
		if !this.Debugs[i].Equal(that1.Debugs[i]) {
			return false
		}
	}
	return true
}
func (this *PBPoints) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PBPoints)
	if !ok {
		that2, ok := that.(PBPoints)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Arr) != len(that1.Arr) {
		return false
	}
	for i := range this.Arr {
		if !this.Arr[i].Equal(that1.Arr[i]) {
			return false
		}
	}
	return true
}
func (this *Debug) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&gogopb.Debug{")
	s = append(s, "Info: "+fmt.Sprintf("%#v", this.Info)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AnyDemo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&gogopb.AnyDemo{")
	s = append(s, "Demo: "+fmt.Sprintf("%#v", this.Demo)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BasicTypes) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&gogopb.BasicTypes{")
	if this.X != nil {
		s = append(s, "X: "+fmt.Sprintf("%#v", this.X)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BasicTypes_I) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.BasicTypes_I{` +
		`I:` + fmt.Sprintf("%#v", this.I) + `}`}, ", ")
	return s
}
func (this *BasicTypes_U) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.BasicTypes_U{` +
		`U:` + fmt.Sprintf("%#v", this.U) + `}`}, ", ")
	return s
}
func (this *BasicTypes_F) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.BasicTypes_F{` +
		`F:` + fmt.Sprintf("%#v", this.F) + `}`}, ", ")
	return s
}
func (this *BasicTypes_B) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.BasicTypes_B{` +
		`B:` + fmt.Sprintf("%#v", this.B) + `}`}, ", ")
	return s
}
func (this *BasicTypes_D) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.BasicTypes_D{` +
		`D:` + fmt.Sprintf("%#v", this.D) + `}`}, ", ")
	return s
}
func (this *BasicTypes_S) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.BasicTypes_S{` +
		`S:` + fmt.Sprintf("%#v", this.S) + `}`}, ", ")
	return s
}
func (this *Array) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&gogopb.Array{")
	if this.Arr != nil {
		s = append(s, "Arr: "+fmt.Sprintf("%#v", this.Arr)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Map) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&gogopb.Map{")
	keysForMap := make([]string, 0, len(this.Map))
	for k, _ := range this.Map {
		keysForMap = append(keysForMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMap)
	mapStringForMap := "map[string]*BasicTypes{"
	for _, k := range keysForMap {
		mapStringForMap += fmt.Sprintf("%#v: %#v,", k, this.Map[k])
	}
	mapStringForMap += "}"
	if this.Map != nil {
		s = append(s, "Map: "+mapStringForMap+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Field) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&gogopb.Field{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	if this.Val != nil {
		s = append(s, "Val: "+fmt.Sprintf("%#v", this.Val)+",\n")
	}
	s = append(s, "IsTag: "+fmt.Sprintf("%#v", this.IsTag)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Unit: "+fmt.Sprintf("%#v", this.Unit)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Field_I) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_I{` +
		`I:` + fmt.Sprintf("%#v", this.I) + `}`}, ", ")
	return s
}
func (this *Field_U) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_U{` +
		`U:` + fmt.Sprintf("%#v", this.U) + `}`}, ", ")
	return s
}
func (this *Field_F) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_F{` +
		`F:` + fmt.Sprintf("%#v", this.F) + `}`}, ", ")
	return s
}
func (this *Field_B) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_B{` +
		`B:` + fmt.Sprintf("%#v", this.B) + `}`}, ", ")
	return s
}
func (this *Field_D) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_D{` +
		`D:` + fmt.Sprintf("%#v", this.D) + `}`}, ", ")
	return s
}
func (this *Field_S) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_S{` +
		`S:` + fmt.Sprintf("%#v", this.S) + `}`}, ", ")
	return s
}
func (this *Field_A) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&gogopb.Field_A{` +
		`A:` + fmt.Sprintf("%#v", this.A) + `}`}, ", ")
	return s
}
func (this *Warn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&gogopb.Warn{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Msg: "+fmt.Sprintf("%#v", this.Msg)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PBPoint) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&gogopb.PBPoint{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Fields != nil {
		s = append(s, "Fields: "+fmt.Sprintf("%#v", this.Fields)+",\n")
	}
	s = append(s, "Time: "+fmt.Sprintf("%#v", this.Time)+",\n")
	if this.Warns != nil {
		s = append(s, "Warns: "+fmt.Sprintf("%#v", this.Warns)+",\n")
	}
	if this.Debugs != nil {
		s = append(s, "Debugs: "+fmt.Sprintf("%#v", this.Debugs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PBPoints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&gogopb.PBPoints{")
	if this.Arr != nil {
		s = append(s, "Arr: "+fmt.Sprintf("%#v", this.Arr)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringPoint(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Debug) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *Debug) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Info) > 0 {
		i -= len(m.Info)
		copy(dAtA[i:], m.Info)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Info)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *AnyDemo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Demo) > 0 {
		i -= len(m.Demo)
		copy(dAtA[i:], m.Demo)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Demo)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *BasicTypes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.X != nil {
		{
			size := m.X.Size()
			i -= size
			if _, err := m.X.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *BasicTypes_I) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintPoint(dAtA, i, uint64(m.I))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}
func (m *BasicTypes_U) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BasicTypes_U) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintPoint(dAtA, i, uint64(m.U))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *BasicTypes_F) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BasicTypes_F) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.F))))
	i--
	dAtA[i] = 0x19
	return len(dAtA) - i, nil
}
func (m *BasicTypes_B) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BasicTypes_B) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.B {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	return len(dAtA) - i, nil
}
func (m *BasicTypes_D) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BasicTypes_D) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.D != nil {
		i -= len(m.D)
		copy(dAtA[i:], m.D)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.D)))
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *BasicTypes_S) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BasicTypes_S) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.S)
	copy(dAtA[i:], m.S)
	i = encodeVarintPoint(dAtA, i, uint64(len(m.S)))
	i--
	dAtA[i] = 0x32
	return len(dAtA) - i, nil
}
func (m *Array) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

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

func (m *Map) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Map) > 0 {
		for k := range m.Map {
			v := m.Map[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintPoint(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintPoint(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintPoint(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Field) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Val != nil {
		{
			size := m.Val.Size()
			i -= size
			if _, err := m.Val.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Unit) > 0 {
		i -= len(m.Unit)
		copy(dAtA[i:], m.Unit)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Unit)))
		i--
		dAtA[i] = 0x52
	}
	if m.Type != 0 {
		i = encodeVarintPoint(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x48
	}
	if m.IsTag {
		i--
		if m.IsTag {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Field_I) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintPoint(dAtA, i, uint64(m.I))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *Field_U) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field_U) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintPoint(dAtA, i, uint64(m.U))
	i--
	dAtA[i] = 0x18
	return len(dAtA) - i, nil
}
func (m *Field_F) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field_F) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.F))))
	i--
	dAtA[i] = 0x21
	return len(dAtA) - i, nil
}
func (m *Field_B) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field_B) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.B {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x28
	return len(dAtA) - i, nil
}
func (m *Field_D) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field_D) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.D != nil {
		i -= len(m.D)
		copy(dAtA[i:], m.D)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.D)))
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *Field_A) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field_A) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.A != nil {
		{
			size, err := m.A.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPoint(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *Field_S) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Field_S) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.S)
	copy(dAtA[i:], m.S)
	i = encodeVarintPoint(dAtA, i, uint64(len(m.S)))
	i--
	dAtA[i] = 0x5a
	return len(dAtA) - i, nil
}
func (m *Warn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *Warn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Msg) > 0 {
		i -= len(m.Msg)
		copy(dAtA[i:], m.Msg)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Msg)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *PBPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Debugs) > 0 {
		for iNdEx := len(m.Debugs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Debugs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintPoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Warns) > 0 {
		for iNdEx := len(m.Warns) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Warns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintPoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Time != 0 {
		i = encodeVarintPoint(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Fields) > 0 {
		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Fields[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintPoint(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintPoint(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func encodeVarintPoint(dAtA []byte, offset int, v uint64) int {
	offset -= sovPoint(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Debug) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Info)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}

func (m *AnyDemo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Demo)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}

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

func (m *BasicTypes_I) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPoint(uint64(m.I))
	return n
}
func (m *BasicTypes_U) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPoint(uint64(m.U))
	return n
}
func (m *BasicTypes_F) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	return n
}
func (m *BasicTypes_B) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *BasicTypes_D) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.D != nil {
		l = len(m.D)
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}
func (m *BasicTypes_S) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.S)
	n += 1 + l + sovPoint(uint64(l))
	return n
}
func (m *Array) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Arr) > 0 {
		for _, e := range m.Arr {
			l = e.Size()
			n += 1 + l + sovPoint(uint64(l))
		}
	}
	return n
}

func (m *Map) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Map) > 0 {
		for k, v := range m.Map {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovPoint(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovPoint(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovPoint(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *Field) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	if m.Val != nil {
		n += m.Val.Size()
	}
	if m.IsTag {
		n += 2
	}
	if m.Type != 0 {
		n += 1 + sovPoint(uint64(m.Type))
	}
	l = len(m.Unit)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}

func (m *Field_I) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPoint(uint64(m.I))
	return n
}
func (m *Field_U) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPoint(uint64(m.U))
	return n
}
func (m *Field_F) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	return n
}
func (m *Field_B) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *Field_D) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.D != nil {
		l = len(m.D)
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}
func (m *Field_A) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.A != nil {
		l = m.A.Size()
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}
func (m *Field_S) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.S)
	n += 1 + l + sovPoint(uint64(l))
	return n
}
func (m *Warn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	return n
}

func (m *PBPoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovPoint(uint64(l))
	}
	if len(m.Fields) > 0 {
		for _, e := range m.Fields {
			l = e.Size()
			n += 1 + l + sovPoint(uint64(l))
		}
	}
	if m.Time != 0 {
		n += 1 + sovPoint(uint64(m.Time))
	}
	if len(m.Warns) > 0 {
		for _, e := range m.Warns {
			l = e.Size()
			n += 1 + l + sovPoint(uint64(l))
		}
	}
	if len(m.Debugs) > 0 {
		for _, e := range m.Debugs {
			l = e.Size()
			n += 1 + l + sovPoint(uint64(l))
		}
	}
	return n
}

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

func sovPoint(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozPoint(x uint64) (n int) {
	return sovPoint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Debug) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Debug{`,
		`Info:` + fmt.Sprintf("%v", this.Info) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AnyDemo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AnyDemo{`,
		`Demo:` + fmt.Sprintf("%v", this.Demo) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes{`,
		`X:` + fmt.Sprintf("%v", this.X) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes_I) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes_I{`,
		`I:` + fmt.Sprintf("%v", this.I) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes_U) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes_U{`,
		`U:` + fmt.Sprintf("%v", this.U) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes_F) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes_F{`,
		`F:` + fmt.Sprintf("%v", this.F) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes_B) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes_B{`,
		`B:` + fmt.Sprintf("%v", this.B) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes_D) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes_D{`,
		`D:` + fmt.Sprintf("%v", this.D) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BasicTypes_S) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BasicTypes_S{`,
		`S:` + fmt.Sprintf("%v", this.S) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Array) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArr := "[]*BasicTypes{"
	for _, f := range this.Arr {
		repeatedStringForArr += strings.Replace(f.String(), "BasicTypes", "BasicTypes", 1) + ","
	}
	repeatedStringForArr += "}"
	s := strings.Join([]string{`&Array{`,
		`Arr:` + repeatedStringForArr + `,`,
		`}`,
	}, "")
	return s
}
func (this *Map) String() string {
	if this == nil {
		return "nil"
	}
	keysForMap := make([]string, 0, len(this.Map))
	for k, _ := range this.Map {
		keysForMap = append(keysForMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMap)
	mapStringForMap := "map[string]*BasicTypes{"
	for _, k := range keysForMap {
		mapStringForMap += fmt.Sprintf("%v: %v,", k, this.Map[k])
	}
	mapStringForMap += "}"
	s := strings.Join([]string{`&Map{`,
		`Map:` + mapStringForMap + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Val:` + fmt.Sprintf("%v", this.Val) + `,`,
		`IsTag:` + fmt.Sprintf("%v", this.IsTag) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Unit:` + fmt.Sprintf("%v", this.Unit) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_I) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_I{`,
		`I:` + fmt.Sprintf("%v", this.I) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_U) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_U{`,
		`U:` + fmt.Sprintf("%v", this.U) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_F) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_F{`,
		`F:` + fmt.Sprintf("%v", this.F) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_B) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_B{`,
		`B:` + fmt.Sprintf("%v", this.B) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_D) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_D{`,
		`D:` + fmt.Sprintf("%v", this.D) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_A) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_A{`,
		`A:` + strings.Replace(fmt.Sprintf("%v", this.A), "Any", "types.Any", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Field_S) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Field_S{`,
		`S:` + fmt.Sprintf("%v", this.S) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Warn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Warn{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Msg:` + fmt.Sprintf("%v", this.Msg) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PBPoint) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForFields := "[]*Field{"
	for _, f := range this.Fields {
		repeatedStringForFields += strings.Replace(f.String(), "Field", "Field", 1) + ","
	}
	repeatedStringForFields += "}"
	repeatedStringForWarns := "[]*Warn{"
	for _, f := range this.Warns {
		repeatedStringForWarns += strings.Replace(f.String(), "Warn", "Warn", 1) + ","
	}
	repeatedStringForWarns += "}"
	repeatedStringForDebugs := "[]*Debug{"
	for _, f := range this.Debugs {
		repeatedStringForDebugs += strings.Replace(f.String(), "Debug", "Debug", 1) + ","
	}
	repeatedStringForDebugs += "}"
	s := strings.Join([]string{`&PBPoint{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Fields:` + repeatedStringForFields + `,`,
		`Time:` + fmt.Sprintf("%v", this.Time) + `,`,
		`Warns:` + repeatedStringForWarns + `,`,
		`Debugs:` + repeatedStringForDebugs + `,`,
		`}`,
	}, "")
	return s
}
func (this *PBPoints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArr := "[]*PBPoint{"
	for _, f := range this.Arr {
		repeatedStringForArr += strings.Replace(f.String(), "PBPoint", "PBPoint", 1) + ","
	}
	repeatedStringForArr += "}"
	s := strings.Join([]string{`&PBPoints{`,
		`Arr:` + repeatedStringForArr + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringPoint(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Debug) 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 ErrIntOverflowPoint
			}
			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: Debug: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Debug: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				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 ErrInvalidLengthPoint
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Info = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BasicTypes) 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 ErrIntOverflowPoint
			}
			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: BasicTypes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BasicTypes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.X = &BasicTypes_I{v}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field U", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.X = &BasicTypes_U{v}
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.X = &BasicTypes_F{float64(math.Float64frombits(v))}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.X = &BasicTypes_B{b}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := make([]byte, postIndex-iNdEx)
			copy(v, dAtA[iNdEx:postIndex])
			m.X = &BasicTypes_D{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field S", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				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 ErrInvalidLengthPoint
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.X = &BasicTypes_S{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Map) 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 ErrIntOverflowPoint
			}
			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: Map: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Map: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Map == nil {
				m.Map = make(map[string]*BasicTypes)
			}
			var mapkey string
			var mapvalue *BasicTypes
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowPoint
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPoint
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthPoint
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthPoint
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPoint
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthPoint
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthPoint
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &BasicTypes{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipPoint(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthPoint
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Map[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Field) 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 ErrIntOverflowPoint
			}
			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: Field: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				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 ErrInvalidLengthPoint
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field I", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Val = &Field_I{v}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field U", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Val = &Field_U{v}
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Val = &Field_F{float64(math.Float64frombits(v))}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Val = &Field_B{b}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := make([]byte, postIndex-iNdEx)
			copy(v, dAtA[iNdEx:postIndex])
			m.Val = &Field_D{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &types.Any{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Val = &Field_A{v}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsTag", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsTag = bool(v != 0)
		case 9:
			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 ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= MetricType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				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 ErrInvalidLengthPoint
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Unit = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field S", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				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 ErrInvalidLengthPoint
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Val = &Field_S{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PBPoint) 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 ErrIntOverflowPoint
			}
			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: PBPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PBPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				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 ErrInvalidLengthPoint
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, &Field{})
			if err := m.Fields[len(m.Fields)-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 Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Warns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Warns = append(m.Warns, &Warn{})
			if err := m.Warns[len(m.Warns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Debugs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPoint
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPoint
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPoint
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Debugs = append(m.Debugs, &Debug{})
			if err := m.Debugs[len(m.Debugs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPoint(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPoint
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipPoint(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, ErrIntOverflowPoint
			}
			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, ErrIntOverflowPoint
				}
				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, ErrIntOverflowPoint
				}
				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, ErrInvalidLengthPoint
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupPoint
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthPoint
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthPoint        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPoint          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupPoint = fmt.Errorf("proto: unexpected end of group")
)