dataset.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: zvelo/msg/dataset.proto

package msg

import proto "github.com/gogo/protobuf/proto"
import golang_proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import strconv "strconv"

import strings "strings"
import reflect "reflect"

import io "io"

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

type DataSetType int32

const (
	CATEGORIZATION DataSetType = 0
	// 1 is reserved
	// 2 is reserved
	// 3 is reserved
	MALICIOUS DataSetType = 4
	ECHO      DataSetType = 5
	// 6 is reserved
	LANGUAGE DataSetType = 7
)

var DataSetType_name = map[int32]string{
	0: "CATEGORIZATION",
	4: "MALICIOUS",
	5: "ECHO",
	7: "LANGUAGE",
}
var DataSetType_value = map[string]int32{
	"CATEGORIZATION": 0,
	"MALICIOUS":      4,
	"ECHO":           5,
	"LANGUAGE":       7,
}

func (DataSetType) EnumDescriptor() ([]byte, []int) { return fileDescriptorDataset, []int{0} }

// DataSet
type DataSet struct {
	Categorization *DataSet_Categorization `protobuf:"bytes,1,opt,name=categorization" json:"categorization,omitempty"`
	Malicious      *DataSet_Malicious      `protobuf:"bytes,5,opt,name=malicious" json:"malicious,omitempty"`
	Echo           *DataSet_Echo           `protobuf:"bytes,6,opt,name=echo" json:"echo,omitempty"`
	Language       *DataSet_Language       `protobuf:"bytes,8,opt,name=language" json:"language,omitempty"`
}

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

func (m *DataSet) GetCategorization() *DataSet_Categorization {
	if m != nil {
		return m.Categorization
	}
	return nil
}

func (m *DataSet) GetMalicious() *DataSet_Malicious {
	if m != nil {
		return m.Malicious
	}
	return nil
}

func (m *DataSet) GetEcho() *DataSet_Echo {
	if m != nil {
		return m.Echo
	}
	return nil
}

func (m *DataSet) GetLanguage() *DataSet_Language {
	if m != nil {
		return m.Language
	}
	return nil
}

// Categorization
type DataSet_Categorization struct {
	Value []Category `protobuf:"varint,3,rep,packed,name=value,enum=zvelo.msg.Category" json:"value,omitempty"`
	Error *Status    `protobuf:"bytes,4,opt,name=error" json:"error,omitempty"`
}

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

func (m *DataSet_Categorization) GetValue() []Category {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *DataSet_Categorization) GetError() *Status {
	if m != nil {
		return m.Error
	}
	return nil
}

type DataSet_Language struct {
	Code  string  `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	Error *Status `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"`
}

func (m *DataSet_Language) Reset()                    { *m = DataSet_Language{} }
func (*DataSet_Language) ProtoMessage()               {}
func (*DataSet_Language) Descriptor() ([]byte, []int) { return fileDescriptorDataset, []int{0, 1} }

func (m *DataSet_Language) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func (m *DataSet_Language) GetError() *Status {
	if m != nil {
		return m.Error
	}
	return nil
}

// Malicious
type DataSet_Malicious struct {
	Error    *Status    `protobuf:"bytes,8,opt,name=error" json:"error,omitempty"`
	Category []Category `protobuf:"varint,9,rep,packed,name=category,enum=zvelo.msg.Category" json:"category,omitempty"`
}

func (m *DataSet_Malicious) Reset()                    { *m = DataSet_Malicious{} }
func (*DataSet_Malicious) ProtoMessage()               {}
func (*DataSet_Malicious) Descriptor() ([]byte, []int) { return fileDescriptorDataset, []int{0, 2} }

func (m *DataSet_Malicious) GetError() *Status {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *DataSet_Malicious) GetCategory() []Category {
	if m != nil {
		return m.Category
	}
	return nil
}

// Echo
type DataSet_Echo struct {
	Url   string  `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Error *Status `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"`
}

func (m *DataSet_Echo) Reset()                    { *m = DataSet_Echo{} }
func (*DataSet_Echo) ProtoMessage()               {}
func (*DataSet_Echo) Descriptor() ([]byte, []int) { return fileDescriptorDataset, []int{0, 3} }

func (m *DataSet_Echo) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *DataSet_Echo) GetError() *Status {
	if m != nil {
		return m.Error
	}
	return nil
}

func init() {
	proto.RegisterType((*DataSet)(nil), "zvelo.msg.DataSet")
	golang_proto.RegisterType((*DataSet)(nil), "zvelo.msg.DataSet")
	proto.RegisterType((*DataSet_Categorization)(nil), "zvelo.msg.DataSet.Categorization")
	golang_proto.RegisterType((*DataSet_Categorization)(nil), "zvelo.msg.DataSet.Categorization")
	proto.RegisterType((*DataSet_Language)(nil), "zvelo.msg.DataSet.Language")
	golang_proto.RegisterType((*DataSet_Language)(nil), "zvelo.msg.DataSet.Language")
	proto.RegisterType((*DataSet_Malicious)(nil), "zvelo.msg.DataSet.Malicious")
	golang_proto.RegisterType((*DataSet_Malicious)(nil), "zvelo.msg.DataSet.Malicious")
	proto.RegisterType((*DataSet_Echo)(nil), "zvelo.msg.DataSet.Echo")
	golang_proto.RegisterType((*DataSet_Echo)(nil), "zvelo.msg.DataSet.Echo")
	proto.RegisterEnum("zvelo.msg.DataSetType", DataSetType_name, DataSetType_value)
	golang_proto.RegisterEnum("zvelo.msg.DataSetType", DataSetType_name, DataSetType_value)
}
func (x DataSetType) String() string {
	s, ok := DataSetType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *DataSet) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DataSet)
	if !ok {
		that2, ok := that.(DataSet)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DataSet")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DataSet but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DataSet but is not nil && this == nil")
	}
	if !this.Categorization.Equal(that1.Categorization) {
		return fmt.Errorf("Categorization this(%v) Not Equal that(%v)", this.Categorization, that1.Categorization)
	}
	if !this.Malicious.Equal(that1.Malicious) {
		return fmt.Errorf("Malicious this(%v) Not Equal that(%v)", this.Malicious, that1.Malicious)
	}
	if !this.Echo.Equal(that1.Echo) {
		return fmt.Errorf("Echo this(%v) Not Equal that(%v)", this.Echo, that1.Echo)
	}
	if !this.Language.Equal(that1.Language) {
		return fmt.Errorf("Language this(%v) Not Equal that(%v)", this.Language, that1.Language)
	}
	return nil
}
func (this *DataSet) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataSet)
	if !ok {
		that2, ok := that.(DataSet)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Categorization.Equal(that1.Categorization) {
		return false
	}
	if !this.Malicious.Equal(that1.Malicious) {
		return false
	}
	if !this.Echo.Equal(that1.Echo) {
		return false
	}
	if !this.Language.Equal(that1.Language) {
		return false
	}
	return true
}
func (this *DataSet_Categorization) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DataSet_Categorization)
	if !ok {
		that2, ok := that.(DataSet_Categorization)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DataSet_Categorization")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DataSet_Categorization but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DataSet_Categorization but is not nil && this == nil")
	}
	if len(this.Value) != len(that1.Value) {
		return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value))
	}
	for i := range this.Value {
		if this.Value[i] != that1.Value[i] {
			return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i])
		}
	}
	if !this.Error.Equal(that1.Error) {
		return fmt.Errorf("Error this(%v) Not Equal that(%v)", this.Error, that1.Error)
	}
	return nil
}
func (this *DataSet_Categorization) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataSet_Categorization)
	if !ok {
		that2, ok := that.(DataSet_Categorization)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Value) != len(that1.Value) {
		return false
	}
	for i := range this.Value {
		if this.Value[i] != that1.Value[i] {
			return false
		}
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	return true
}
func (this *DataSet_Language) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DataSet_Language)
	if !ok {
		that2, ok := that.(DataSet_Language)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DataSet_Language")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DataSet_Language but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DataSet_Language but is not nil && this == nil")
	}
	if this.Code != that1.Code {
		return fmt.Errorf("Code this(%v) Not Equal that(%v)", this.Code, that1.Code)
	}
	if !this.Error.Equal(that1.Error) {
		return fmt.Errorf("Error this(%v) Not Equal that(%v)", this.Error, that1.Error)
	}
	return nil
}
func (this *DataSet_Language) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataSet_Language)
	if !ok {
		that2, ok := that.(DataSet_Language)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Code != that1.Code {
		return false
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	return true
}
func (this *DataSet_Malicious) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DataSet_Malicious)
	if !ok {
		that2, ok := that.(DataSet_Malicious)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DataSet_Malicious")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DataSet_Malicious but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DataSet_Malicious but is not nil && this == nil")
	}
	if !this.Error.Equal(that1.Error) {
		return fmt.Errorf("Error this(%v) Not Equal that(%v)", this.Error, that1.Error)
	}
	if len(this.Category) != len(that1.Category) {
		return fmt.Errorf("Category this(%v) Not Equal that(%v)", len(this.Category), len(that1.Category))
	}
	for i := range this.Category {
		if this.Category[i] != that1.Category[i] {
			return fmt.Errorf("Category this[%v](%v) Not Equal that[%v](%v)", i, this.Category[i], i, that1.Category[i])
		}
	}
	return nil
}
func (this *DataSet_Malicious) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataSet_Malicious)
	if !ok {
		that2, ok := that.(DataSet_Malicious)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	if len(this.Category) != len(that1.Category) {
		return false
	}
	for i := range this.Category {
		if this.Category[i] != that1.Category[i] {
			return false
		}
	}
	return true
}
func (this *DataSet_Echo) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DataSet_Echo)
	if !ok {
		that2, ok := that.(DataSet_Echo)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DataSet_Echo")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DataSet_Echo but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DataSet_Echo but is not nil && this == nil")
	}
	if this.Url != that1.Url {
		return fmt.Errorf("Url this(%v) Not Equal that(%v)", this.Url, that1.Url)
	}
	if !this.Error.Equal(that1.Error) {
		return fmt.Errorf("Error this(%v) Not Equal that(%v)", this.Error, that1.Error)
	}
	return nil
}
func (this *DataSet_Echo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataSet_Echo)
	if !ok {
		that2, ok := that.(DataSet_Echo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Url != that1.Url {
		return false
	}
	if !this.Error.Equal(that1.Error) {
		return false
	}
	return true
}
func (this *DataSet) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&msg.DataSet{")
	if this.Categorization != nil {
		s = append(s, "Categorization: "+fmt.Sprintf("%#v", this.Categorization)+",\n")
	}
	if this.Malicious != nil {
		s = append(s, "Malicious: "+fmt.Sprintf("%#v", this.Malicious)+",\n")
	}
	if this.Echo != nil {
		s = append(s, "Echo: "+fmt.Sprintf("%#v", this.Echo)+",\n")
	}
	if this.Language != nil {
		s = append(s, "Language: "+fmt.Sprintf("%#v", this.Language)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataSet_Categorization) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&msg.DataSet_Categorization{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataSet_Language) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&msg.DataSet_Language{")
	s = append(s, "Code: "+fmt.Sprintf("%#v", this.Code)+",\n")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataSet_Malicious) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&msg.DataSet_Malicious{")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "Category: "+fmt.Sprintf("%#v", this.Category)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataSet_Echo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&msg.DataSet_Echo{")
	s = append(s, "Url: "+fmt.Sprintf("%#v", this.Url)+",\n")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringDataset(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 *DataSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DataSet) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Categorization != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Categorization.Size()))
		n1, err := m.Categorization.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Malicious != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Malicious.Size()))
		n2, err := m.Malicious.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Echo != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Echo.Size()))
		n3, err := m.Echo.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Language != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Language.Size()))
		n4, err := m.Language.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

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

func (m *DataSet_Categorization) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		dAtA6 := make([]byte, len(m.Value)*10)
		var j5 int
		for _, num := range m.Value {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDataset(dAtA, i, uint64(j5))
		i += copy(dAtA[i:], dAtA6[:j5])
	}
	if m.Error != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Error.Size()))
		n7, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}

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

func (m *DataSet_Language) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Code) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDataset(dAtA, i, uint64(len(m.Code)))
		i += copy(dAtA[i:], m.Code)
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Error.Size()))
		n8, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}

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

func (m *DataSet_Malicious) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Error.Size()))
		n9, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if len(m.Category) > 0 {
		dAtA11 := make([]byte, len(m.Category)*10)
		var j10 int
		for _, num := range m.Category {
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		dAtA[i] = 0x4a
		i++
		i = encodeVarintDataset(dAtA, i, uint64(j10))
		i += copy(dAtA[i:], dAtA11[:j10])
	}
	return i, nil
}

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

func (m *DataSet_Echo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDataset(dAtA, i, uint64(len(m.Url)))
		i += copy(dAtA[i:], m.Url)
	}
	if m.Error != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDataset(dAtA, i, uint64(m.Error.Size()))
		n12, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}

func encodeVarintDataset(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *DataSet) Size() (n int) {
	var l int
	_ = l
	if m.Categorization != nil {
		l = m.Categorization.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	if m.Malicious != nil {
		l = m.Malicious.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	if m.Echo != nil {
		l = m.Echo.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	if m.Language != nil {
		l = m.Language.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	return n
}

func (m *DataSet_Categorization) Size() (n int) {
	var l int
	_ = l
	if len(m.Value) > 0 {
		l = 0
		for _, e := range m.Value {
			l += sovDataset(uint64(e))
		}
		n += 1 + sovDataset(uint64(l)) + l
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	return n
}

func (m *DataSet_Language) Size() (n int) {
	var l int
	_ = l
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovDataset(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	return n
}

func (m *DataSet_Malicious) Size() (n int) {
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	if len(m.Category) > 0 {
		l = 0
		for _, e := range m.Category {
			l += sovDataset(uint64(e))
		}
		n += 1 + sovDataset(uint64(l)) + l
	}
	return n
}

func (m *DataSet_Echo) Size() (n int) {
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovDataset(uint64(l))
	}
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovDataset(uint64(l))
	}
	return n
}

func sovDataset(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozDataset(x uint64) (n int) {
	return sovDataset(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *DataSet) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataSet{`,
		`Categorization:` + strings.Replace(fmt.Sprintf("%v", this.Categorization), "DataSet_Categorization", "DataSet_Categorization", 1) + `,`,
		`Malicious:` + strings.Replace(fmt.Sprintf("%v", this.Malicious), "DataSet_Malicious", "DataSet_Malicious", 1) + `,`,
		`Echo:` + strings.Replace(fmt.Sprintf("%v", this.Echo), "DataSet_Echo", "DataSet_Echo", 1) + `,`,
		`Language:` + strings.Replace(fmt.Sprintf("%v", this.Language), "DataSet_Language", "DataSet_Language", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataSet_Categorization) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataSet_Categorization{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Status", "Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataSet_Language) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataSet_Language{`,
		`Code:` + fmt.Sprintf("%v", this.Code) + `,`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Status", "Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataSet_Malicious) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataSet_Malicious{`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Status", "Status", 1) + `,`,
		`Category:` + fmt.Sprintf("%v", this.Category) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataSet_Echo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataSet_Echo{`,
		`Url:` + fmt.Sprintf("%v", this.Url) + `,`,
		`Error:` + strings.Replace(fmt.Sprintf("%v", this.Error), "Status", "Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringDataset(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *DataSet) 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 ErrIntOverflowDataset
			}
			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: DataSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Categorization", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Categorization == nil {
				m.Categorization = &DataSet_Categorization{}
			}
			if err := m.Categorization.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Malicious", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Malicious == nil {
				m.Malicious = &DataSet_Malicious{}
			}
			if err := m.Malicious.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Echo == nil {
				m.Echo = &DataSet_Echo{}
			}
			if err := m.Echo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Language", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Language == nil {
				m.Language = &DataSet_Language{}
			}
			if err := m.Language.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDataset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDataset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataSet_Categorization) 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 ErrIntOverflowDataset
			}
			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: Categorization: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Categorization: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType == 0 {
				var v Category
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDataset
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (Category(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Value = append(m.Value, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDataset
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDataset
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v Category
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDataset
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (Category(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Value = append(m.Value, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Status{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDataset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDataset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataSet_Language) 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 ErrIntOverflowDataset
			}
			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: Language: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Language: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				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 ErrInvalidLengthDataset
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Code = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Status{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDataset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDataset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataSet_Malicious) 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 ErrIntOverflowDataset
			}
			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: Malicious: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Malicious: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Status{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType == 0 {
				var v Category
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDataset
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (Category(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Category = append(m.Category, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDataset
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDataset
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v Category
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDataset
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (Category(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Category = append(m.Category, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDataset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDataset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataSet_Echo) 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 ErrIntOverflowDataset
			}
			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: Echo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Echo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				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 ErrInvalidLengthDataset
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDataset
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDataset
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Error == nil {
				m.Error = &Status{}
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDataset(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDataset
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

func init() { proto.RegisterFile("zvelo/msg/dataset.proto", fileDescriptorDataset) }
func init() { golang_proto.RegisterFile("zvelo/msg/dataset.proto", fileDescriptorDataset) }

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