features.pb.go

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

package dlframework

import (
	bytes "bytes"
	compress_gzip "compress/gzip"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	golang_proto "github.com/golang/protobuf/proto"
	io "io"
	io_ioutil "io/ioutil"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_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 FeatureType int32

const (
	FeatureType_UNKNOWN         FeatureType = 0
	FeatureType_IMAGE           FeatureType = 1
	FeatureType_RAW_IMAGE       FeatureType = 2
	FeatureType_CLASSIFICATION  FeatureType = 3
	FeatureType_BOUNDINGBOX     FeatureType = 4
	FeatureType_SEMANTICSEGMENT FeatureType = 5
	FeatureType_INSTANCESEGMENT FeatureType = 6
	FeatureType_GEOLOCATION     FeatureType = 7
	FeatureType_REGION          FeatureType = 8
	FeatureType_TEXT            FeatureType = 9
	FeatureType_AUDIO           FeatureType = 10
	FeatureType_GENERAL         FeatureType = 11
	FeatureType_RAW             FeatureType = 100
)

var FeatureType_name = map[int32]string{
	0:   "UNKNOWN",
	1:   "IMAGE",
	2:   "RAW_IMAGE",
	3:   "CLASSIFICATION",
	4:   "BOUNDINGBOX",
	5:   "SEMANTICSEGMENT",
	6:   "INSTANCESEGMENT",
	7:   "GEOLOCATION",
	8:   "REGION",
	9:   "TEXT",
	10:  "AUDIO",
	11:  "GENERAL",
	100: "RAW",
}

var FeatureType_value = map[string]int32{
	"UNKNOWN":         0,
	"IMAGE":           1,
	"RAW_IMAGE":       2,
	"CLASSIFICATION":  3,
	"BOUNDINGBOX":     4,
	"SEMANTICSEGMENT": 5,
	"INSTANCESEGMENT": 6,
	"GEOLOCATION":     7,
	"REGION":          8,
	"TEXT":            9,
	"AUDIO":           10,
	"GENERAL":         11,
	"RAW":             100,
}

func (x FeatureType) String() string {
	return proto.EnumName(FeatureType_name, int32(x))
}

func (FeatureType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2216f05915163cdf, []int{0}
}

type Image struct {
	// An id used to identify the output feature: maps to input_id for output
	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id,omitempty"`
	// The image is base64 encoded
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty" yaml:"data,omitempty"`
}

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

var xxx_messageInfo_Image proto.InternalMessageInfo

func (m *Image) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Image) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type RawImage struct {
	// An id used to identify the output feature: maps to input_id for output
	ID        string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id,omitempty"`
	DataType  string    `protobuf:"bytes,2,opt,name=data_type,json=dataType,proto3" json:"data_type,omitempty" yaml:"data_type,omitempty"`
	CharList  []int32   `protobuf:"varint,3,rep,packed,name=char_list,json=charList,proto3" json:"char_list,omitempty" yaml:"char_list,omitempty"`
	FloatList []float32 `protobuf:"fixed32,4,rep,packed,name=float_list,json=floatList,proto3" json:"float_list,omitempty" yaml:"float_list,omitempty"`
	Width     int32     `protobuf:"varint,5,opt,name=width,proto3" json:"width,omitempty" yaml:"width,omitempty"`
	Height    int32     `protobuf:"varint,6,opt,name=height,proto3" json:"height,omitempty" yaml:"height,omitempty"`
	Channels  int32     `protobuf:"varint,7,opt,name=channels,proto3" json:"channels,omitempty" yaml:"channels,omitempty"`
	// compressed data is only used by the webserver and javascript codes
	CompressedData []byte `protobuf:"bytes,8,opt,name=compressed_data,json=compressedData,proto3" json:"compressed_data,omitempty" yaml:"compressed_data,omitempty"`
	// jpeg data is only used by the webserver and javascript codes
	JpegData []byte `protobuf:"bytes,9,opt,name=jpeg_data,json=jpegData,proto3" json:"jpeg_data,omitempty" yaml:"jpeg_data,omitempty"`
}

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

var xxx_messageInfo_RawImage proto.InternalMessageInfo

func (m *RawImage) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *RawImage) GetDataType() string {
	if m != nil {
		return m.DataType
	}
	return ""
}

func (m *RawImage) GetCharList() []int32 {
	if m != nil {
		return m.CharList
	}
	return nil
}

func (m *RawImage) GetFloatList() []float32 {
	if m != nil {
		return m.FloatList
	}
	return nil
}

func (m *RawImage) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *RawImage) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *RawImage) GetChannels() int32 {
	if m != nil {
		return m.Channels
	}
	return 0
}

func (m *RawImage) GetCompressedData() []byte {
	if m != nil {
		return m.CompressedData
	}
	return nil
}

func (m *RawImage) GetJpegData() []byte {
	if m != nil {
		return m.JpegData
	}
	return nil
}

type Classification struct {
	Index int32  `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty" yaml:"index,omitempty"`
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty" yaml:"label,omitempty"`
}

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

var xxx_messageInfo_Classification proto.InternalMessageInfo

func (m *Classification) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *Classification) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

type BoundingBox struct {
	Index int32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty" yaml:"index,omitempty"`
	Label string  `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty" yaml:"label,omitempty"`
	Xmin  float32 `protobuf:"fixed32,3,opt,name=xmin,proto3" json:"xmin,omitempty" yaml:"xmin,omitempty"`
	Xmax  float32 `protobuf:"fixed32,4,opt,name=xmax,proto3" json:"xmax,omitempty" yaml:"xmax,omitempty"`
	Ymin  float32 `protobuf:"fixed32,5,opt,name=ymin,proto3" json:"ymin,omitempty" yaml:"ymin,omitempty"`
	Ymax  float32 `protobuf:"fixed32,6,opt,name=ymax,proto3" json:"ymax,omitempty" yaml:"ymax,omitempty"`
}

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

var xxx_messageInfo_BoundingBox proto.InternalMessageInfo

func (m *BoundingBox) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *BoundingBox) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *BoundingBox) GetXmin() float32 {
	if m != nil {
		return m.Xmin
	}
	return 0
}

func (m *BoundingBox) GetXmax() float32 {
	if m != nil {
		return m.Xmax
	}
	return 0
}

func (m *BoundingBox) GetYmin() float32 {
	if m != nil {
		return m.Ymin
	}
	return 0
}

func (m *BoundingBox) GetYmax() float32 {
	if m != nil {
		return m.Ymax
	}
	return 0
}

type SemanticSegment struct {
	Height  int32    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty" yaml:"height,omitempty"`
	Width   int32    `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty" yaml:"width,omitempty"`
	IntMask []int32  `protobuf:"varint,3,rep,packed,name=int_mask,json=intMask,proto3" json:"int_mask,omitempty" yaml:"int_mask,omitempty"`
	Labels  []string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" yaml:"labels,omitempty"`
}

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

var xxx_messageInfo_SemanticSegment proto.InternalMessageInfo

func (m *SemanticSegment) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *SemanticSegment) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *SemanticSegment) GetIntMask() []int32 {
	if m != nil {
		return m.IntMask
	}
	return nil
}

func (m *SemanticSegment) GetLabels() []string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type InstanceSegment struct {
	Index     int32     `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty" yaml:"index,omitempty"`
	Label     string    `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty" yaml:"label,omitempty"`
	Xmin      float32   `protobuf:"fixed32,3,opt,name=xmin,proto3" json:"xmin,omitempty" yaml:"xmin,omitempty"`
	Xmax      float32   `protobuf:"fixed32,4,opt,name=xmax,proto3" json:"xmax,omitempty" yaml:"xmax,omitempty"`
	Ymin      float32   `protobuf:"fixed32,5,opt,name=ymin,proto3" json:"ymin,omitempty" yaml:"ymin,omitempty"`
	Ymax      float32   `protobuf:"fixed32,6,opt,name=ymax,proto3" json:"ymax,omitempty" yaml:"ymax,omitempty"`
	MaskType  string    `protobuf:"bytes,7,opt,name=mask_type,json=maskType,proto3" json:"mask_type,omitempty" yaml:"mask_type,omitempty"`
	Height    int32     `protobuf:"varint,8,opt,name=height,proto3" json:"height,omitempty" yaml:"height,omitempty"`
	Width     int32     `protobuf:"varint,9,opt,name=width,proto3" json:"width,omitempty" yaml:"width,omitempty"`
	IntMask   []int32   `protobuf:"varint,10,rep,packed,name=int_mask,json=intMask,proto3" json:"int_mask,omitempty" yaml:"int_mask,omitempty"`
	FloatMask []float32 `protobuf:"fixed32,11,rep,packed,name=float_mask,json=floatMask,proto3" json:"float_mask,omitempty" yaml:"float_mask,omitempty"`
}

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

var xxx_messageInfo_InstanceSegment proto.InternalMessageInfo

func (m *InstanceSegment) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *InstanceSegment) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *InstanceSegment) GetXmin() float32 {
	if m != nil {
		return m.Xmin
	}
	return 0
}

func (m *InstanceSegment) GetXmax() float32 {
	if m != nil {
		return m.Xmax
	}
	return 0
}

func (m *InstanceSegment) GetYmin() float32 {
	if m != nil {
		return m.Ymin
	}
	return 0
}

func (m *InstanceSegment) GetYmax() float32 {
	if m != nil {
		return m.Ymax
	}
	return 0
}

func (m *InstanceSegment) GetMaskType() string {
	if m != nil {
		return m.MaskType
	}
	return ""
}

func (m *InstanceSegment) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *InstanceSegment) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *InstanceSegment) GetIntMask() []int32 {
	if m != nil {
		return m.IntMask
	}
	return nil
}

func (m *InstanceSegment) GetFloatMask() []float32 {
	if m != nil {
		return m.FloatMask
	}
	return nil
}

type GeoLocation struct {
	Index     int32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty" yaml:"index,omitempty"`
	Latitude  float32 `protobuf:"fixed32,2,opt,name=latitude,proto3" json:"latitude,omitempty" yaml:"latitude,omitempty"`
	Longitude float32 `protobuf:"fixed32,3,opt,name=longitude,proto3" json:"longitude,omitempty" yaml:"longitude,omitempty"`
}

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

var xxx_messageInfo_GeoLocation proto.InternalMessageInfo

func (m *GeoLocation) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *GeoLocation) GetLatitude() float32 {
	if m != nil {
		return m.Latitude
	}
	return 0
}

func (m *GeoLocation) GetLongitude() float32 {
	if m != nil {
		return m.Longitude
	}
	return 0
}

type Region struct {
	Data   []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" yaml:"data,omitempty"`
	Format string `protobuf:"bytes,2,opt,name=format,proto3" json:"format,omitempty" yaml:"format,omitempty"`
}

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

var xxx_messageInfo_Region proto.InternalMessageInfo

func (m *Region) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Region) GetFormat() string {
	if m != nil {
		return m.Format
	}
	return ""
}

type Text struct {
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty" yaml:"data,omitempty"`
}

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

var xxx_messageInfo_Text proto.InternalMessageInfo

func (m *Text) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type Audio struct {
	Data   []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" yaml:"data,omitempty"`
	Format string `protobuf:"bytes,2,opt,name=format,proto3" json:"format,omitempty" yaml:"format,omitempty"`
}

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

var xxx_messageInfo_Audio proto.InternalMessageInfo

func (m *Audio) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Audio) GetFormat() string {
	if m != nil {
		return m.Format
	}
	return ""
}

type General struct {
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty" yaml:"data,omitempty"`
}

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

var xxx_messageInfo_General proto.InternalMessageInfo

func (m *General) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type Raw struct {
	Data   []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" yaml:"data,omitempty"`
	Format string `protobuf:"bytes,2,opt,name=format,proto3" json:"format,omitempty" yaml:"format,omitempty"`
}

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

var xxx_messageInfo_Raw proto.InternalMessageInfo

func (m *Raw) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Raw) GetFormat() string {
	if m != nil {
		return m.Format
	}
	return ""
}

type Feature struct {
	ID          string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id,omitempty"`
	Type        FeatureType       `protobuf:"varint,3,opt,name=type,proto3,enum=mlmodelscope.org.dlframework.FeatureType" json:"type,omitempty" yaml:"type,omitempty"`
	Probability float32           `protobuf:"fixed32,4,opt,name=probability,proto3" json:"probability,omitempty" yaml:"probability,omitempty"`
	Metadata    map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" yaml:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Types that are valid to be assigned to Feature:
	//	*Feature_Image
	//	*Feature_RawImage
	//	*Feature_Classification
	//	*Feature_BoundingBox
	//	*Feature_SemanticSegment
	//	*Feature_InstanceSegment
	//	*Feature_Text
	//	*Feature_Region
	//	*Feature_Audio
	//	*Feature_Geolocation
	//	*Feature_General
	//	*Feature_Raw
	Feature isFeature_Feature `protobuf_oneof:"feature"`
}

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

var xxx_messageInfo_Feature proto.InternalMessageInfo

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

type Feature_Image struct {
	Image *Image `protobuf:"bytes,6,opt,name=image,proto3,oneof" json:"image,omitempty" yaml:"image,omitempty"`
}
type Feature_RawImage struct {
	RawImage *RawImage `protobuf:"bytes,7,opt,name=raw_image,json=rawImage,proto3,oneof" json:"raw_image,omitempty" yaml:"image,omitempty"`
}
type Feature_Classification struct {
	Classification *Classification `protobuf:"bytes,8,opt,name=classification,proto3,oneof" json:"classification,omitempty" yaml:"classification,omitempty"`
}
type Feature_BoundingBox struct {
	BoundingBox *BoundingBox `protobuf:"bytes,9,opt,name=bounding_box,json=boundingBox,proto3,oneof" json:"bounding_box,omitempty" yaml:"boundingbox,omitempty"`
}
type Feature_SemanticSegment struct {
	SemanticSegment *SemanticSegment `protobuf:"bytes,10,opt,name=semantic_segment,json=semanticSegment,proto3,oneof" json:"semantic_segment,omitempty" yaml:"semantic_segment,omitempty"`
}
type Feature_InstanceSegment struct {
	InstanceSegment *InstanceSegment `protobuf:"bytes,11,opt,name=instance_segment,json=instanceSegment,proto3,oneof" json:"instance_segment,omitempty" yaml:"instancesegment,omitempty"`
}
type Feature_Text struct {
	Text *Text `protobuf:"bytes,12,opt,name=text,proto3,oneof" json:"text,omitempty" yaml:"text,omitempty"`
}
type Feature_Region struct {
	Region *Region `protobuf:"bytes,13,opt,name=region,proto3,oneof" json:"region,omitempty" yaml:"region,omitempty"`
}
type Feature_Audio struct {
	Audio *Audio `protobuf:"bytes,14,opt,name=audio,proto3,oneof" json:"audio,omitempty" yaml:"audio,omitempty"`
}
type Feature_Geolocation struct {
	Geolocation *GeoLocation `protobuf:"bytes,15,opt,name=geolocation,proto3,oneof" json:"geolocation,omitempty" yaml:"geolocation,omitempty"`
}
type Feature_General struct {
	General *General `protobuf:"bytes,16,opt,name=general,proto3,oneof" json:"general,omitempty" yaml:"general,omitempty"`
}
type Feature_Raw struct {
	Raw *Raw `protobuf:"bytes,1000,opt,name=raw,proto3,oneof" json:"raw,omitempty" yaml:"raw,omitempty"`
}

func (*Feature_Image) isFeature_Feature()           {}
func (*Feature_RawImage) isFeature_Feature()        {}
func (*Feature_Classification) isFeature_Feature()  {}
func (*Feature_BoundingBox) isFeature_Feature()     {}
func (*Feature_SemanticSegment) isFeature_Feature() {}
func (*Feature_InstanceSegment) isFeature_Feature() {}
func (*Feature_Text) isFeature_Feature()            {}
func (*Feature_Region) isFeature_Feature()          {}
func (*Feature_Audio) isFeature_Feature()           {}
func (*Feature_Geolocation) isFeature_Feature()     {}
func (*Feature_General) isFeature_Feature()         {}
func (*Feature_Raw) isFeature_Feature()             {}

func (m *Feature) GetFeature() isFeature_Feature {
	if m != nil {
		return m.Feature
	}
	return nil
}

func (m *Feature) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Feature) GetType() FeatureType {
	if m != nil {
		return m.Type
	}
	return FeatureType_UNKNOWN
}

func (m *Feature) GetProbability() float32 {
	if m != nil {
		return m.Probability
	}
	return 0
}

func (m *Feature) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Feature) GetImage() *Image {
	if x, ok := m.GetFeature().(*Feature_Image); ok {
		return x.Image
	}
	return nil
}

func (m *Feature) GetRawImage() *RawImage {
	if x, ok := m.GetFeature().(*Feature_RawImage); ok {
		return x.RawImage
	}
	return nil
}

func (m *Feature) GetClassification() *Classification {
	if x, ok := m.GetFeature().(*Feature_Classification); ok {
		return x.Classification
	}
	return nil
}

func (m *Feature) GetBoundingBox() *BoundingBox {
	if x, ok := m.GetFeature().(*Feature_BoundingBox); ok {
		return x.BoundingBox
	}
	return nil
}

func (m *Feature) GetSemanticSegment() *SemanticSegment {
	if x, ok := m.GetFeature().(*Feature_SemanticSegment); ok {
		return x.SemanticSegment
	}
	return nil
}

func (m *Feature) GetInstanceSegment() *InstanceSegment {
	if x, ok := m.GetFeature().(*Feature_InstanceSegment); ok {
		return x.InstanceSegment
	}
	return nil
}

func (m *Feature) GetText() *Text {
	if x, ok := m.GetFeature().(*Feature_Text); ok {
		return x.Text
	}
	return nil
}

func (m *Feature) GetRegion() *Region {
	if x, ok := m.GetFeature().(*Feature_Region); ok {
		return x.Region
	}
	return nil
}

func (m *Feature) GetAudio() *Audio {
	if x, ok := m.GetFeature().(*Feature_Audio); ok {
		return x.Audio
	}
	return nil
}

func (m *Feature) GetGeolocation() *GeoLocation {
	if x, ok := m.GetFeature().(*Feature_Geolocation); ok {
		return x.Geolocation
	}
	return nil
}

func (m *Feature) GetGeneral() *General {
	if x, ok := m.GetFeature().(*Feature_General); ok {
		return x.General
	}
	return nil
}

func (m *Feature) GetRaw() *Raw {
	if x, ok := m.GetFeature().(*Feature_Raw); ok {
		return x.Raw
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Feature) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Feature_Image)(nil),
		(*Feature_RawImage)(nil),
		(*Feature_Classification)(nil),
		(*Feature_BoundingBox)(nil),
		(*Feature_SemanticSegment)(nil),
		(*Feature_InstanceSegment)(nil),
		(*Feature_Text)(nil),
		(*Feature_Region)(nil),
		(*Feature_Audio)(nil),
		(*Feature_Geolocation)(nil),
		(*Feature_General)(nil),
		(*Feature_Raw)(nil),
	}
}

func init() {
	proto.RegisterEnum("mlmodelscope.org.dlframework.FeatureType", FeatureType_name, FeatureType_value)
	golang_proto.RegisterEnum("mlmodelscope.org.dlframework.FeatureType", FeatureType_name, FeatureType_value)
	proto.RegisterType((*Image)(nil), "mlmodelscope.org.dlframework.Image")
	golang_proto.RegisterType((*Image)(nil), "mlmodelscope.org.dlframework.Image")
	proto.RegisterType((*RawImage)(nil), "mlmodelscope.org.dlframework.RawImage")
	golang_proto.RegisterType((*RawImage)(nil), "mlmodelscope.org.dlframework.RawImage")
	proto.RegisterType((*Classification)(nil), "mlmodelscope.org.dlframework.Classification")
	golang_proto.RegisterType((*Classification)(nil), "mlmodelscope.org.dlframework.Classification")
	proto.RegisterType((*BoundingBox)(nil), "mlmodelscope.org.dlframework.BoundingBox")
	golang_proto.RegisterType((*BoundingBox)(nil), "mlmodelscope.org.dlframework.BoundingBox")
	proto.RegisterType((*SemanticSegment)(nil), "mlmodelscope.org.dlframework.SemanticSegment")
	golang_proto.RegisterType((*SemanticSegment)(nil), "mlmodelscope.org.dlframework.SemanticSegment")
	proto.RegisterType((*InstanceSegment)(nil), "mlmodelscope.org.dlframework.InstanceSegment")
	golang_proto.RegisterType((*InstanceSegment)(nil), "mlmodelscope.org.dlframework.InstanceSegment")
	proto.RegisterType((*GeoLocation)(nil), "mlmodelscope.org.dlframework.GeoLocation")
	golang_proto.RegisterType((*GeoLocation)(nil), "mlmodelscope.org.dlframework.GeoLocation")
	proto.RegisterType((*Region)(nil), "mlmodelscope.org.dlframework.Region")
	golang_proto.RegisterType((*Region)(nil), "mlmodelscope.org.dlframework.Region")
	proto.RegisterType((*Text)(nil), "mlmodelscope.org.dlframework.Text")
	golang_proto.RegisterType((*Text)(nil), "mlmodelscope.org.dlframework.Text")
	proto.RegisterType((*Audio)(nil), "mlmodelscope.org.dlframework.Audio")
	golang_proto.RegisterType((*Audio)(nil), "mlmodelscope.org.dlframework.Audio")
	proto.RegisterType((*General)(nil), "mlmodelscope.org.dlframework.General")
	golang_proto.RegisterType((*General)(nil), "mlmodelscope.org.dlframework.General")
	proto.RegisterType((*Raw)(nil), "mlmodelscope.org.dlframework.Raw")
	golang_proto.RegisterType((*Raw)(nil), "mlmodelscope.org.dlframework.Raw")
	proto.RegisterType((*Feature)(nil), "mlmodelscope.org.dlframework.Feature")
	golang_proto.RegisterType((*Feature)(nil), "mlmodelscope.org.dlframework.Feature")
	proto.RegisterMapType((map[string]string)(nil), "mlmodelscope.org.dlframework.Feature.MetadataEntry")
	golang_proto.RegisterMapType((map[string]string)(nil), "mlmodelscope.org.dlframework.Feature.MetadataEntry")
}

func init() { proto.RegisterFile("features.proto", fileDescriptor_2216f05915163cdf) }
func init() { golang_proto.RegisterFile("features.proto", fileDescriptor_2216f05915163cdf) }

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

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

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

	that1, ok := that.(*Image)
	if !ok {
		that2, ok := that.(Image)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (this *RawImage) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*RawImage)
	if !ok {
		that2, ok := that.(RawImage)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *RawImage")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *RawImage but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *RawImage but is not nil && this == nil")
	}
	if this.ID != that1.ID {
		return fmt.Errorf("ID this(%v) Not Equal that(%v)", this.ID, that1.ID)
	}
	if this.DataType != that1.DataType {
		return fmt.Errorf("DataType this(%v) Not Equal that(%v)", this.DataType, that1.DataType)
	}
	if len(this.CharList) != len(that1.CharList) {
		return fmt.Errorf("CharList this(%v) Not Equal that(%v)", len(this.CharList), len(that1.CharList))
	}
	for i := range this.CharList {
		if this.CharList[i] != that1.CharList[i] {
			return fmt.Errorf("CharList this[%v](%v) Not Equal that[%v](%v)", i, this.CharList[i], i, that1.CharList[i])
		}
	}
	if len(this.FloatList) != len(that1.FloatList) {
		return fmt.Errorf("FloatList this(%v) Not Equal that(%v)", len(this.FloatList), len(that1.FloatList))
	}
	for i := range this.FloatList {
		if this.FloatList[i] != that1.FloatList[i] {
			return fmt.Errorf("FloatList this[%v](%v) Not Equal that[%v](%v)", i, this.FloatList[i], i, that1.FloatList[i])
		}
	}
	if this.Width != that1.Width {
		return fmt.Errorf("Width this(%v) Not Equal that(%v)", this.Width, that1.Width)
	}
	if this.Height != that1.Height {
		return fmt.Errorf("Height this(%v) Not Equal that(%v)", this.Height, that1.Height)
	}
	if this.Channels != that1.Channels {
		return fmt.Errorf("Channels this(%v) Not Equal that(%v)", this.Channels, that1.Channels)
	}
	if !bytes.Equal(this.CompressedData, that1.CompressedData) {
		return fmt.Errorf("CompressedData this(%v) Not Equal that(%v)", this.CompressedData, that1.CompressedData)
	}
	if !bytes.Equal(this.JpegData, that1.JpegData) {
		return fmt.Errorf("JpegData this(%v) Not Equal that(%v)", this.JpegData, that1.JpegData)
	}
	return nil
}
func (this *RawImage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RawImage)
	if !ok {
		that2, ok := that.(RawImage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.DataType != that1.DataType {
		return false
	}
	if len(this.CharList) != len(that1.CharList) {
		return false
	}
	for i := range this.CharList {
		if this.CharList[i] != that1.CharList[i] {
			return false
		}
	}
	if len(this.FloatList) != len(that1.FloatList) {
		return false
	}
	for i := range this.FloatList {
		if this.FloatList[i] != that1.FloatList[i] {
			return false
		}
	}
	if this.Width != that1.Width {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if this.Channels != that1.Channels {
		return false
	}
	if !bytes.Equal(this.CompressedData, that1.CompressedData) {
		return false
	}
	if !bytes.Equal(this.JpegData, that1.JpegData) {
		return false
	}
	return true
}
func (this *Classification) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*Classification)
	if !ok {
		that2, ok := that.(Classification)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	if this.Label != that1.Label {
		return false
	}
	return true
}
func (this *BoundingBox) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*BoundingBox)
	if !ok {
		that2, ok := that.(BoundingBox)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *BoundingBox")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *BoundingBox but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *BoundingBox but is not nil && this == nil")
	}
	if this.Index != that1.Index {
		return fmt.Errorf("Index this(%v) Not Equal that(%v)", this.Index, that1.Index)
	}
	if this.Label != that1.Label {
		return fmt.Errorf("Label this(%v) Not Equal that(%v)", this.Label, that1.Label)
	}
	if this.Xmin != that1.Xmin {
		return fmt.Errorf("Xmin this(%v) Not Equal that(%v)", this.Xmin, that1.Xmin)
	}
	if this.Xmax != that1.Xmax {
		return fmt.Errorf("Xmax this(%v) Not Equal that(%v)", this.Xmax, that1.Xmax)
	}
	if this.Ymin != that1.Ymin {
		return fmt.Errorf("Ymin this(%v) Not Equal that(%v)", this.Ymin, that1.Ymin)
	}
	if this.Ymax != that1.Ymax {
		return fmt.Errorf("Ymax this(%v) Not Equal that(%v)", this.Ymax, that1.Ymax)
	}
	return nil
}
func (this *BoundingBox) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BoundingBox)
	if !ok {
		that2, ok := that.(BoundingBox)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	if this.Label != that1.Label {
		return false
	}
	if this.Xmin != that1.Xmin {
		return false
	}
	if this.Xmax != that1.Xmax {
		return false
	}
	if this.Ymin != that1.Ymin {
		return false
	}
	if this.Ymax != that1.Ymax {
		return false
	}
	return true
}
func (this *SemanticSegment) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*SemanticSegment)
	if !ok {
		that2, ok := that.(SemanticSegment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if this.Width != that1.Width {
		return false
	}
	if len(this.IntMask) != len(that1.IntMask) {
		return false
	}
	for i := range this.IntMask {
		if this.IntMask[i] != that1.IntMask[i] {
			return false
		}
	}
	if len(this.Labels) != len(that1.Labels) {
		return false
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return false
		}
	}
	return true
}
func (this *InstanceSegment) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*InstanceSegment)
	if !ok {
		that2, ok := that.(InstanceSegment)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *InstanceSegment")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *InstanceSegment but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *InstanceSegment but is not nil && this == nil")
	}
	if this.Index != that1.Index {
		return fmt.Errorf("Index this(%v) Not Equal that(%v)", this.Index, that1.Index)
	}
	if this.Label != that1.Label {
		return fmt.Errorf("Label this(%v) Not Equal that(%v)", this.Label, that1.Label)
	}
	if this.Xmin != that1.Xmin {
		return fmt.Errorf("Xmin this(%v) Not Equal that(%v)", this.Xmin, that1.Xmin)
	}
	if this.Xmax != that1.Xmax {
		return fmt.Errorf("Xmax this(%v) Not Equal that(%v)", this.Xmax, that1.Xmax)
	}
	if this.Ymin != that1.Ymin {
		return fmt.Errorf("Ymin this(%v) Not Equal that(%v)", this.Ymin, that1.Ymin)
	}
	if this.Ymax != that1.Ymax {
		return fmt.Errorf("Ymax this(%v) Not Equal that(%v)", this.Ymax, that1.Ymax)
	}
	if this.MaskType != that1.MaskType {
		return fmt.Errorf("MaskType this(%v) Not Equal that(%v)", this.MaskType, that1.MaskType)
	}
	if this.Height != that1.Height {
		return fmt.Errorf("Height this(%v) Not Equal that(%v)", this.Height, that1.Height)
	}
	if this.Width != that1.Width {
		return fmt.Errorf("Width this(%v) Not Equal that(%v)", this.Width, that1.Width)
	}
	if len(this.IntMask) != len(that1.IntMask) {
		return fmt.Errorf("IntMask this(%v) Not Equal that(%v)", len(this.IntMask), len(that1.IntMask))
	}
	for i := range this.IntMask {
		if this.IntMask[i] != that1.IntMask[i] {
			return fmt.Errorf("IntMask this[%v](%v) Not Equal that[%v](%v)", i, this.IntMask[i], i, that1.IntMask[i])
		}
	}
	if len(this.FloatMask) != len(that1.FloatMask) {
		return fmt.Errorf("FloatMask this(%v) Not Equal that(%v)", len(this.FloatMask), len(that1.FloatMask))
	}
	for i := range this.FloatMask {
		if this.FloatMask[i] != that1.FloatMask[i] {
			return fmt.Errorf("FloatMask this[%v](%v) Not Equal that[%v](%v)", i, this.FloatMask[i], i, that1.FloatMask[i])
		}
	}
	return nil
}
func (this *InstanceSegment) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*InstanceSegment)
	if !ok {
		that2, ok := that.(InstanceSegment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	if this.Label != that1.Label {
		return false
	}
	if this.Xmin != that1.Xmin {
		return false
	}
	if this.Xmax != that1.Xmax {
		return false
	}
	if this.Ymin != that1.Ymin {
		return false
	}
	if this.Ymax != that1.Ymax {
		return false
	}
	if this.MaskType != that1.MaskType {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if this.Width != that1.Width {
		return false
	}
	if len(this.IntMask) != len(that1.IntMask) {
		return false
	}
	for i := range this.IntMask {
		if this.IntMask[i] != that1.IntMask[i] {
			return false
		}
	}
	if len(this.FloatMask) != len(that1.FloatMask) {
		return false
	}
	for i := range this.FloatMask {
		if this.FloatMask[i] != that1.FloatMask[i] {
			return false
		}
	}
	return true
}
func (this *GeoLocation) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*GeoLocation)
	if !ok {
		that2, ok := that.(GeoLocation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	if this.Latitude != that1.Latitude {
		return false
	}
	if this.Longitude != that1.Longitude {
		return false
	}
	return true
}
func (this *Region) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*Region)
	if !ok {
		that2, ok := that.(Region)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.Format != that1.Format {
		return false
	}
	return true
}
func (this *Text) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*Text)
	if !ok {
		that2, ok := that.(Text)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (this *Audio) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*Audio)
	if !ok {
		that2, ok := that.(Audio)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.Format != that1.Format {
		return false
	}
	return true
}
func (this *General) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*General)
	if !ok {
		that2, ok := that.(General)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (this *Raw) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

	that1, ok := that.(*Raw)
	if !ok {
		that2, ok := that.(Raw)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.Format != that1.Format {
		return false
	}
	return true
}
func (this *Feature) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature)
	if !ok {
		that2, ok := that.(Feature)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature but is not nil && this == nil")
	}
	if this.ID != that1.ID {
		return fmt.Errorf("ID this(%v) Not Equal that(%v)", this.ID, that1.ID)
	}
	if this.Type != that1.Type {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if this.Probability != that1.Probability {
		return fmt.Errorf("Probability this(%v) Not Equal that(%v)", this.Probability, that1.Probability)
	}
	if len(this.Metadata) != len(that1.Metadata) {
		return fmt.Errorf("Metadata this(%v) Not Equal that(%v)", len(this.Metadata), len(that1.Metadata))
	}
	for i := range this.Metadata {
		if this.Metadata[i] != that1.Metadata[i] {
			return fmt.Errorf("Metadata this[%v](%v) Not Equal that[%v](%v)", i, this.Metadata[i], i, that1.Metadata[i])
		}
	}
	if that1.Feature == nil {
		if this.Feature != nil {
			return fmt.Errorf("this.Feature != nil && that1.Feature == nil")
		}
	} else if this.Feature == nil {
		return fmt.Errorf("this.Feature == nil && that1.Feature != nil")
	} else if err := this.Feature.VerboseEqual(that1.Feature); err != nil {
		return err
	}
	return nil
}
func (this *Feature_Image) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_Image)
	if !ok {
		that2, ok := that.(Feature_Image)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_Image")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_Image but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_Image but is not nil && this == nil")
	}
	if !this.Image.Equal(that1.Image) {
		return fmt.Errorf("Image this(%v) Not Equal that(%v)", this.Image, that1.Image)
	}
	return nil
}
func (this *Feature_RawImage) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_RawImage)
	if !ok {
		that2, ok := that.(Feature_RawImage)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_RawImage")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_RawImage but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_RawImage but is not nil && this == nil")
	}
	if !this.RawImage.Equal(that1.RawImage) {
		return fmt.Errorf("RawImage this(%v) Not Equal that(%v)", this.RawImage, that1.RawImage)
	}
	return nil
}
func (this *Feature_Classification) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_Classification)
	if !ok {
		that2, ok := that.(Feature_Classification)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_Classification")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_Classification but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_Classification but is not nil && this == nil")
	}
	if !this.Classification.Equal(that1.Classification) {
		return fmt.Errorf("Classification this(%v) Not Equal that(%v)", this.Classification, that1.Classification)
	}
	return nil
}
func (this *Feature_BoundingBox) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_BoundingBox)
	if !ok {
		that2, ok := that.(Feature_BoundingBox)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_BoundingBox")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_BoundingBox but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_BoundingBox but is not nil && this == nil")
	}
	if !this.BoundingBox.Equal(that1.BoundingBox) {
		return fmt.Errorf("BoundingBox this(%v) Not Equal that(%v)", this.BoundingBox, that1.BoundingBox)
	}
	return nil
}
func (this *Feature_SemanticSegment) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_SemanticSegment)
	if !ok {
		that2, ok := that.(Feature_SemanticSegment)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_SemanticSegment")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_SemanticSegment but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_SemanticSegment but is not nil && this == nil")
	}
	if !this.SemanticSegment.Equal(that1.SemanticSegment) {
		return fmt.Errorf("SemanticSegment this(%v) Not Equal that(%v)", this.SemanticSegment, that1.SemanticSegment)
	}
	return nil
}
func (this *Feature_InstanceSegment) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_InstanceSegment)
	if !ok {
		that2, ok := that.(Feature_InstanceSegment)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_InstanceSegment")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_InstanceSegment but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_InstanceSegment but is not nil && this == nil")
	}
	if !this.InstanceSegment.Equal(that1.InstanceSegment) {
		return fmt.Errorf("InstanceSegment this(%v) Not Equal that(%v)", this.InstanceSegment, that1.InstanceSegment)
	}
	return nil
}
func (this *Feature_Text) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_Text)
	if !ok {
		that2, ok := that.(Feature_Text)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_Text")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_Text but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_Text but is not nil && this == nil")
	}
	if !this.Text.Equal(that1.Text) {
		return fmt.Errorf("Text this(%v) Not Equal that(%v)", this.Text, that1.Text)
	}
	return nil
}
func (this *Feature_Region) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_Region)
	if !ok {
		that2, ok := that.(Feature_Region)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_Region")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_Region but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_Region but is not nil && this == nil")
	}
	if !this.Region.Equal(that1.Region) {
		return fmt.Errorf("Region this(%v) Not Equal that(%v)", this.Region, that1.Region)
	}
	return nil
}
func (this *Feature_Audio) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_Audio)
	if !ok {
		that2, ok := that.(Feature_Audio)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_Audio")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_Audio but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_Audio but is not nil && this == nil")
	}
	if !this.Audio.Equal(that1.Audio) {
		return fmt.Errorf("Audio this(%v) Not Equal that(%v)", this.Audio, that1.Audio)
	}
	return nil
}
func (this *Feature_Geolocation) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_Geolocation)
	if !ok {
		that2, ok := that.(Feature_Geolocation)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_Geolocation")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_Geolocation but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_Geolocation but is not nil && this == nil")
	}
	if !this.Geolocation.Equal(that1.Geolocation) {
		return fmt.Errorf("Geolocation this(%v) Not Equal that(%v)", this.Geolocation, that1.Geolocation)
	}
	return nil
}
func (this *Feature_General) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Feature_General)
	if !ok {
		that2, ok := that.(Feature_General)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Feature_General")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Feature_General but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Feature_General but is not nil && this == nil")
	}
	if !this.General.Equal(that1.General) {
		return fmt.Errorf("General this(%v) Not Equal that(%v)", this.General, that1.General)
	}
	return nil
}
func (this *Feature_Raw) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*Feature_Raw)
	if !ok {
		that2, ok := that.(Feature_Raw)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Raw.Equal(that1.Raw) {
		return false
	}
	return true
}
func (this *Image) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&dlframework.Image{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RawImage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&dlframework.RawImage{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "DataType: "+fmt.Sprintf("%#v", this.DataType)+",\n")
	s = append(s, "CharList: "+fmt.Sprintf("%#v", this.CharList)+",\n")
	s = append(s, "FloatList: "+fmt.Sprintf("%#v", this.FloatList)+",\n")
	s = append(s, "Width: "+fmt.Sprintf("%#v", this.Width)+",\n")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "Channels: "+fmt.Sprintf("%#v", this.Channels)+",\n")
	s = append(s, "CompressedData: "+fmt.Sprintf("%#v", this.CompressedData)+",\n")
	s = append(s, "JpegData: "+fmt.Sprintf("%#v", this.JpegData)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Classification) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&dlframework.Classification{")
	s = append(s, "Index: "+fmt.Sprintf("%#v", this.Index)+",\n")
	s = append(s, "Label: "+fmt.Sprintf("%#v", this.Label)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BoundingBox) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&dlframework.BoundingBox{")
	s = append(s, "Index: "+fmt.Sprintf("%#v", this.Index)+",\n")
	s = append(s, "Label: "+fmt.Sprintf("%#v", this.Label)+",\n")
	s = append(s, "Xmin: "+fmt.Sprintf("%#v", this.Xmin)+",\n")
	s = append(s, "Xmax: "+fmt.Sprintf("%#v", this.Xmax)+",\n")
	s = append(s, "Ymin: "+fmt.Sprintf("%#v", this.Ymin)+",\n")
	s = append(s, "Ymax: "+fmt.Sprintf("%#v", this.Ymax)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SemanticSegment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&dlframework.SemanticSegment{")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "Width: "+fmt.Sprintf("%#v", this.Width)+",\n")
	s = append(s, "IntMask: "+fmt.Sprintf("%#v", this.IntMask)+",\n")
	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *InstanceSegment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&dlframework.InstanceSegment{")
	s = append(s, "Index: "+fmt.Sprintf("%#v", this.Index)+",\n")
	s = append(s, "Label: "+fmt.Sprintf("%#v", this.Label)+",\n")
	s = append(s, "Xmin: "+fmt.Sprintf("%#v", this.Xmin)+",\n")
	s = append(s, "Xmax: "+fmt.Sprintf("%#v", this.Xmax)+",\n")
	s = append(s, "Ymin: "+fmt.Sprintf("%#v", this.Ymin)+",\n")
	s = append(s, "Ymax: "+fmt.Sprintf("%#v", this.Ymax)+",\n")
	s = append(s, "MaskType: "+fmt.Sprintf("%#v", this.MaskType)+",\n")
	s = append(s, "Height: "+fmt.Sprintf("%#v", this.Height)+",\n")
	s = append(s, "Width: "+fmt.Sprintf("%#v", this.Width)+",\n")
	s = append(s, "IntMask: "+fmt.Sprintf("%#v", this.IntMask)+",\n")
	s = append(s, "FloatMask: "+fmt.Sprintf("%#v", this.FloatMask)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GeoLocation) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&dlframework.GeoLocation{")
	s = append(s, "Index: "+fmt.Sprintf("%#v", this.Index)+",\n")
	s = append(s, "Latitude: "+fmt.Sprintf("%#v", this.Latitude)+",\n")
	s = append(s, "Longitude: "+fmt.Sprintf("%#v", this.Longitude)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Region) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&dlframework.Region{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "Format: "+fmt.Sprintf("%#v", this.Format)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Text) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&dlframework.Text{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Audio) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&dlframework.Audio{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "Format: "+fmt.Sprintf("%#v", this.Format)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *General) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&dlframework.General{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Raw) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&dlframework.Raw{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "Format: "+fmt.Sprintf("%#v", this.Format)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Feature) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 20)
	s = append(s, "&dlframework.Feature{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Probability: "+fmt.Sprintf("%#v", this.Probability)+",\n")
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k, _ := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%#v: %#v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	if this.Metadata != nil {
		s = append(s, "Metadata: "+mapStringForMetadata+",\n")
	}
	if this.Feature != nil {
		s = append(s, "Feature: "+fmt.Sprintf("%#v", this.Feature)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Feature_Image) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Image{` +
		`Image:` + fmt.Sprintf("%#v", this.Image) + `}`}, ", ")
	return s
}
func (this *Feature_RawImage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_RawImage{` +
		`RawImage:` + fmt.Sprintf("%#v", this.RawImage) + `}`}, ", ")
	return s
}
func (this *Feature_Classification) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Classification{` +
		`Classification:` + fmt.Sprintf("%#v", this.Classification) + `}`}, ", ")
	return s
}
func (this *Feature_BoundingBox) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_BoundingBox{` +
		`BoundingBox:` + fmt.Sprintf("%#v", this.BoundingBox) + `}`}, ", ")
	return s
}
func (this *Feature_SemanticSegment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_SemanticSegment{` +
		`SemanticSegment:` + fmt.Sprintf("%#v", this.SemanticSegment) + `}`}, ", ")
	return s
}
func (this *Feature_InstanceSegment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_InstanceSegment{` +
		`InstanceSegment:` + fmt.Sprintf("%#v", this.InstanceSegment) + `}`}, ", ")
	return s
}
func (this *Feature_Text) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Text{` +
		`Text:` + fmt.Sprintf("%#v", this.Text) + `}`}, ", ")
	return s
}
func (this *Feature_Region) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Region{` +
		`Region:` + fmt.Sprintf("%#v", this.Region) + `}`}, ", ")
	return s
}
func (this *Feature_Audio) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Audio{` +
		`Audio:` + fmt.Sprintf("%#v", this.Audio) + `}`}, ", ")
	return s
}
func (this *Feature_Geolocation) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Geolocation{` +
		`Geolocation:` + fmt.Sprintf("%#v", this.Geolocation) + `}`}, ", ")
	return s
}
func (this *Feature_General) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_General{` +
		`General:` + fmt.Sprintf("%#v", this.General) + `}`}, ", ")
	return s
}
func (this *Feature_Raw) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&dlframework.Feature_Raw{` +
		`Raw:` + fmt.Sprintf("%#v", this.Raw) + `}`}, ", ")
	return s
}
func valueToGoStringFeatures(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 *Image) 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 *Image) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *RawImage) 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 *RawImage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RawImage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JpegData) > 0 {
		i -= len(m.JpegData)
		copy(dAtA[i:], m.JpegData)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.JpegData)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.CompressedData) > 0 {
		i -= len(m.CompressedData)
		copy(dAtA[i:], m.CompressedData)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.CompressedData)))
		i--
		dAtA[i] = 0x42
	}
	if m.Channels != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Channels))
		i--
		dAtA[i] = 0x38
	}
	if m.Height != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x30
	}
	if m.Width != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x28
	}
	if len(m.FloatList) > 0 {
		for iNdEx := len(m.FloatList) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float32bits(float32(m.FloatList[iNdEx]))
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f1))
		}
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.FloatList)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.CharList) > 0 {
		dAtA3 := make([]byte, len(m.CharList)*10)
		var j2 int
		for _, num1 := range m.CharList {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintFeatures(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DataType) > 0 {
		i -= len(m.DataType)
		copy(dAtA[i:], m.DataType)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.DataType)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Classification) 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 *Classification) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Classification) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BoundingBox) 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 *BoundingBox) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BoundingBox) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Ymax != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Ymax))))
		i--
		dAtA[i] = 0x35
	}
	if m.Ymin != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Ymin))))
		i--
		dAtA[i] = 0x2d
	}
	if m.Xmax != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Xmax))))
		i--
		dAtA[i] = 0x25
	}
	if m.Xmin != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Xmin))))
		i--
		dAtA[i] = 0x1d
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *SemanticSegment) 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 *SemanticSegment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SemanticSegment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Labels) > 0 {
		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Labels[iNdEx])
			copy(dAtA[i:], m.Labels[iNdEx])
			i = encodeVarintFeatures(dAtA, i, uint64(len(m.Labels[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.IntMask) > 0 {
		dAtA5 := make([]byte, len(m.IntMask)*10)
		var j4 int
		for _, num1 := range m.IntMask {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		i -= j4
		copy(dAtA[i:], dAtA5[:j4])
		i = encodeVarintFeatures(dAtA, i, uint64(j4))
		i--
		dAtA[i] = 0x1a
	}
	if m.Width != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x10
	}
	if m.Height != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InstanceSegment) 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 *InstanceSegment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InstanceSegment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FloatMask) > 0 {
		for iNdEx := len(m.FloatMask) - 1; iNdEx >= 0; iNdEx-- {
			f6 := math.Float32bits(float32(m.FloatMask[iNdEx]))
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f6))
		}
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.FloatMask)*4))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.IntMask) > 0 {
		dAtA8 := make([]byte, len(m.IntMask)*10)
		var j7 int
		for _, num1 := range m.IntMask {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintFeatures(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x52
	}
	if m.Width != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x48
	}
	if m.Height != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x40
	}
	if len(m.MaskType) > 0 {
		i -= len(m.MaskType)
		copy(dAtA[i:], m.MaskType)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.MaskType)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Ymax != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Ymax))))
		i--
		dAtA[i] = 0x35
	}
	if m.Ymin != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Ymin))))
		i--
		dAtA[i] = 0x2d
	}
	if m.Xmax != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Xmax))))
		i--
		dAtA[i] = 0x25
	}
	if m.Xmin != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Xmin))))
		i--
		dAtA[i] = 0x1d
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x12
	}
	if m.Index != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GeoLocation) 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 *GeoLocation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GeoLocation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Longitude != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Longitude))))
		i--
		dAtA[i] = 0x1d
	}
	if m.Latitude != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Latitude))))
		i--
		dAtA[i] = 0x15
	}
	if m.Index != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Region) 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 *Region) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Text) 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 *Text) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Audio) 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 *Audio) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *General) 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 *General) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Raw) 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 *Raw) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Feature) 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 *Feature) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Feature != nil {
		{
			size := m.Feature.Size()
			i -= size
			if _, err := m.Feature.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Metadata) > 0 {
		for k := range m.Metadata {
			v := m.Metadata[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintFeatures(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintFeatures(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintFeatures(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Probability != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Probability))))
		i--
		dAtA[i] = 0x25
	}
	if m.Type != 0 {
		i = encodeVarintFeatures(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintFeatures(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Feature_Image) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Image != nil {
		{
			size, err := m.Image.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *Feature_RawImage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *Feature_Classification) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Classification != nil {
		{
			size, err := m.Classification.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *Feature_BoundingBox) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_BoundingBox) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BoundingBox != nil {
		{
			size, err := m.BoundingBox.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *Feature_SemanticSegment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_SemanticSegment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SemanticSegment != nil {
		{
			size, err := m.SemanticSegment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *Feature_InstanceSegment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_InstanceSegment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.InstanceSegment != nil {
		{
			size, err := m.InstanceSegment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *Feature_Text) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_Text) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Text != nil {
		{
			size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	return len(dAtA) - i, nil
}
func (m *Feature_Region) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_Region) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Region != nil {
		{
			size, err := m.Region.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	return len(dAtA) - i, nil
}
func (m *Feature_Audio) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_Audio) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Audio != nil {
		{
			size, err := m.Audio.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x72
	}
	return len(dAtA) - i, nil
}
func (m *Feature_Geolocation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_Geolocation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Geolocation != nil {
		{
			size, err := m.Geolocation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x7a
	}
	return len(dAtA) - i, nil
}
func (m *Feature_General) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_General) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.General != nil {
		{
			size, err := m.General.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	return len(dAtA) - i, nil
}
func (m *Feature_Raw) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Feature_Raw) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Raw != nil {
		{
			size, err := m.Raw.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintFeatures(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3e
		i--
		dAtA[i] = 0xc2
	}
	return len(dAtA) - i, nil
}
func encodeVarintFeatures(dAtA []byte, offset int, v uint64) int {
	offset -= sovFeatures(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedImage(r randyFeatures, easy bool) *Image {
	this := &Image{}
	this.ID = string(randStringFeatures(r))
	v1 := r.Intn(100)
	this.Data = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRawImage(r randyFeatures, easy bool) *RawImage {
	this := &RawImage{}
	this.ID = string(randStringFeatures(r))
	this.DataType = string(randStringFeatures(r))
	v2 := r.Intn(10)
	this.CharList = make([]int32, v2)
	for i := 0; i < v2; i++ {
		this.CharList[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.CharList[i] *= -1
		}
	}
	v3 := r.Intn(10)
	this.FloatList = make([]float32, v3)
	for i := 0; i < v3; i++ {
		this.FloatList[i] = float32(r.Float32())
		if r.Intn(2) == 0 {
			this.FloatList[i] *= -1
		}
	}
	this.Width = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Width *= -1
	}
	this.Height = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Height *= -1
	}
	this.Channels = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Channels *= -1
	}
	v4 := r.Intn(100)
	this.CompressedData = make([]byte, v4)
	for i := 0; i < v4; i++ {
		this.CompressedData[i] = byte(r.Intn(256))
	}
	v5 := r.Intn(100)
	this.JpegData = make([]byte, v5)
	for i := 0; i < v5; i++ {
		this.JpegData[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedClassification(r randyFeatures, easy bool) *Classification {
	this := &Classification{}
	this.Index = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Index *= -1
	}
	this.Label = string(randStringFeatures(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedBoundingBox(r randyFeatures, easy bool) *BoundingBox {
	this := &BoundingBox{}
	this.Index = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Index *= -1
	}
	this.Label = string(randStringFeatures(r))
	this.Xmin = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Xmin *= -1
	}
	this.Xmax = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Xmax *= -1
	}
	this.Ymin = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Ymin *= -1
	}
	this.Ymax = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Ymax *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSemanticSegment(r randyFeatures, easy bool) *SemanticSegment {
	this := &SemanticSegment{}
	this.Height = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Height *= -1
	}
	this.Width = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Width *= -1
	}
	v6 := r.Intn(10)
	this.IntMask = make([]int32, v6)
	for i := 0; i < v6; i++ {
		this.IntMask[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.IntMask[i] *= -1
		}
	}
	v7 := r.Intn(10)
	this.Labels = make([]string, v7)
	for i := 0; i < v7; i++ {
		this.Labels[i] = string(randStringFeatures(r))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedInstanceSegment(r randyFeatures, easy bool) *InstanceSegment {
	this := &InstanceSegment{}
	this.Index = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Index *= -1
	}
	this.Label = string(randStringFeatures(r))
	this.Xmin = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Xmin *= -1
	}
	this.Xmax = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Xmax *= -1
	}
	this.Ymin = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Ymin *= -1
	}
	this.Ymax = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Ymax *= -1
	}
	this.MaskType = string(randStringFeatures(r))
	this.Height = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Height *= -1
	}
	this.Width = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Width *= -1
	}
	v8 := r.Intn(10)
	this.IntMask = make([]int32, v8)
	for i := 0; i < v8; i++ {
		this.IntMask[i] = int32(r.Int31())
		if r.Intn(2) == 0 {
			this.IntMask[i] *= -1
		}
	}
	v9 := r.Intn(10)
	this.FloatMask = make([]float32, v9)
	for i := 0; i < v9; i++ {
		this.FloatMask[i] = float32(r.Float32())
		if r.Intn(2) == 0 {
			this.FloatMask[i] *= -1
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGeoLocation(r randyFeatures, easy bool) *GeoLocation {
	this := &GeoLocation{}
	this.Index = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Index *= -1
	}
	this.Latitude = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Latitude *= -1
	}
	this.Longitude = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Longitude *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRegion(r randyFeatures, easy bool) *Region {
	this := &Region{}
	v10 := r.Intn(100)
	this.Data = make([]byte, v10)
	for i := 0; i < v10; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	this.Format = string(randStringFeatures(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedText(r randyFeatures, easy bool) *Text {
	this := &Text{}
	v11 := r.Intn(100)
	this.Data = make([]byte, v11)
	for i := 0; i < v11; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedAudio(r randyFeatures, easy bool) *Audio {
	this := &Audio{}
	v12 := r.Intn(100)
	this.Data = make([]byte, v12)
	for i := 0; i < v12; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	this.Format = string(randStringFeatures(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGeneral(r randyFeatures, easy bool) *General {
	this := &General{}
	v13 := r.Intn(100)
	this.Data = make([]byte, v13)
	for i := 0; i < v13; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRaw(r randyFeatures, easy bool) *Raw {
	this := &Raw{}
	v14 := r.Intn(100)
	this.Data = make([]byte, v14)
	for i := 0; i < v14; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	this.Format = string(randStringFeatures(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedFeature(r randyFeatures, easy bool) *Feature {
	this := &Feature{}
	this.ID = string(randStringFeatures(r))
	this.Type = FeatureType([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 100}[r.Intn(13)])
	this.Probability = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Probability *= -1
	}
	if r.Intn(5) != 0 {
		v15 := r.Intn(10)
		this.Metadata = make(map[string]string)
		for i := 0; i < v15; i++ {
			this.Metadata[randStringFeatures(r)] = randStringFeatures(r)
		}
	}
	oneofNumber_Feature := []int32{6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1000}[r.Intn(12)]
	switch oneofNumber_Feature {
	case 6:
		this.Feature = NewPopulatedFeature_Image(r, easy)
	case 7:
		this.Feature = NewPopulatedFeature_RawImage(r, easy)
	case 8:
		this.Feature = NewPopulatedFeature_Classification(r, easy)
	case 9:
		this.Feature = NewPopulatedFeature_BoundingBox(r, easy)
	case 10:
		this.Feature = NewPopulatedFeature_SemanticSegment(r, easy)
	case 11:
		this.Feature = NewPopulatedFeature_InstanceSegment(r, easy)
	case 12:
		this.Feature = NewPopulatedFeature_Text(r, easy)
	case 13:
		this.Feature = NewPopulatedFeature_Region(r, easy)
	case 14:
		this.Feature = NewPopulatedFeature_Audio(r, easy)
	case 15:
		this.Feature = NewPopulatedFeature_Geolocation(r, easy)
	case 16:
		this.Feature = NewPopulatedFeature_General(r, easy)
	case 1000:
		this.Feature = NewPopulatedFeature_Raw(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedFeature_Image(r randyFeatures, easy bool) *Feature_Image {
	this := &Feature_Image{}
	this.Image = NewPopulatedImage(r, easy)
	return this
}
func NewPopulatedFeature_RawImage(r randyFeatures, easy bool) *Feature_RawImage {
	this := &Feature_RawImage{}
	this.RawImage = NewPopulatedRawImage(r, easy)
	return this
}
func NewPopulatedFeature_Classification(r randyFeatures, easy bool) *Feature_Classification {
	this := &Feature_Classification{}
	this.Classification = NewPopulatedClassification(r, easy)
	return this
}
func NewPopulatedFeature_BoundingBox(r randyFeatures, easy bool) *Feature_BoundingBox {
	this := &Feature_BoundingBox{}
	this.BoundingBox = NewPopulatedBoundingBox(r, easy)
	return this
}
func NewPopulatedFeature_SemanticSegment(r randyFeatures, easy bool) *Feature_SemanticSegment {
	this := &Feature_SemanticSegment{}
	this.SemanticSegment = NewPopulatedSemanticSegment(r, easy)
	return this
}
func NewPopulatedFeature_InstanceSegment(r randyFeatures, easy bool) *Feature_InstanceSegment {
	this := &Feature_InstanceSegment{}
	this.InstanceSegment = NewPopulatedInstanceSegment(r, easy)
	return this
}
func NewPopulatedFeature_Text(r randyFeatures, easy bool) *Feature_Text {
	this := &Feature_Text{}
	this.Text = NewPopulatedText(r, easy)
	return this
}
func NewPopulatedFeature_Region(r randyFeatures, easy bool) *Feature_Region {
	this := &Feature_Region{}
	this.Region = NewPopulatedRegion(r, easy)
	return this
}
func NewPopulatedFeature_Audio(r randyFeatures, easy bool) *Feature_Audio {
	this := &Feature_Audio{}
	this.Audio = NewPopulatedAudio(r, easy)
	return this
}
func NewPopulatedFeature_Geolocation(r randyFeatures, easy bool) *Feature_Geolocation {
	this := &Feature_Geolocation{}
	this.Geolocation = NewPopulatedGeoLocation(r, easy)
	return this
}
func NewPopulatedFeature_General(r randyFeatures, easy bool) *Feature_General {
	this := &Feature_General{}
	this.General = NewPopulatedGeneral(r, easy)
	return this
}
func NewPopulatedFeature_Raw(r randyFeatures, easy bool) *Feature_Raw {
	this := &Feature_Raw{}
	this.Raw = NewPopulatedRaw(r, easy)
	return this
}

type randyFeatures interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneFeatures(r randyFeatures) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringFeatures(r randyFeatures) string {
	v16 := r.Intn(100)
	tmps := make([]rune, v16)
	for i := 0; i < v16; i++ {
		tmps[i] = randUTF8RuneFeatures(r)
	}
	return string(tmps)
}
func randUnrecognizedFeatures(r randyFeatures, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldFeatures(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldFeatures(dAtA []byte, r randyFeatures, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateFeatures(dAtA, uint64(key))
		v17 := r.Int63()
		if r.Intn(2) == 0 {
			v17 *= -1
		}
		dAtA = encodeVarintPopulateFeatures(dAtA, uint64(v17))
	case 1:
		dAtA = encodeVarintPopulateFeatures(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateFeatures(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateFeatures(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateFeatures(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateFeatures(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Image) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}

func (m *RawImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	l = len(m.DataType)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	if len(m.CharList) > 0 {
		l = 0
		for _, e := range m.CharList {
			l += sovFeatures(uint64(e))
		}
		n += 1 + sovFeatures(uint64(l)) + l
	}
	if len(m.FloatList) > 0 {
		n += 1 + sovFeatures(uint64(len(m.FloatList)*4)) + len(m.FloatList)*4
	}
	if m.Width != 0 {
		n += 1 + sovFeatures(uint64(m.Width))
	}
	if m.Height != 0 {
		n += 1 + sovFeatures(uint64(m.Height))
	}
	if m.Channels != 0 {
		n += 1 + sovFeatures(uint64(m.Channels))
	}
	l = len(m.CompressedData)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	l = len(m.JpegData)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}

func (m *Classification) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovFeatures(uint64(m.Index))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}

func (m *BoundingBox) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovFeatures(uint64(m.Index))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	if m.Xmin != 0 {
		n += 5
	}
	if m.Xmax != 0 {
		n += 5
	}
	if m.Ymin != 0 {
		n += 5
	}
	if m.Ymax != 0 {
		n += 5
	}
	return n
}

func (m *SemanticSegment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovFeatures(uint64(m.Height))
	}
	if m.Width != 0 {
		n += 1 + sovFeatures(uint64(m.Width))
	}
	if len(m.IntMask) > 0 {
		l = 0
		for _, e := range m.IntMask {
			l += sovFeatures(uint64(e))
		}
		n += 1 + sovFeatures(uint64(l)) + l
	}
	if len(m.Labels) > 0 {
		for _, s := range m.Labels {
			l = len(s)
			n += 1 + l + sovFeatures(uint64(l))
		}
	}
	return n
}

func (m *InstanceSegment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovFeatures(uint64(m.Index))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	if m.Xmin != 0 {
		n += 5
	}
	if m.Xmax != 0 {
		n += 5
	}
	if m.Ymin != 0 {
		n += 5
	}
	if m.Ymax != 0 {
		n += 5
	}
	l = len(m.MaskType)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovFeatures(uint64(m.Height))
	}
	if m.Width != 0 {
		n += 1 + sovFeatures(uint64(m.Width))
	}
	if len(m.IntMask) > 0 {
		l = 0
		for _, e := range m.IntMask {
			l += sovFeatures(uint64(e))
		}
		n += 1 + sovFeatures(uint64(l)) + l
	}
	if len(m.FloatMask) > 0 {
		n += 1 + sovFeatures(uint64(len(m.FloatMask)*4)) + len(m.FloatMask)*4
	}
	return n
}

func (m *GeoLocation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovFeatures(uint64(m.Index))
	}
	if m.Latitude != 0 {
		n += 5
	}
	if m.Longitude != 0 {
		n += 5
	}
	return n
}

func (m *Region) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	l = len(m.Format)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}

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

func (m *Audio) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	l = len(m.Format)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}

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

func (m *Raw) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	l = len(m.Format)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}

func (m *Feature) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovFeatures(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovFeatures(uint64(m.Type))
	}
	if m.Probability != 0 {
		n += 5
	}
	if len(m.Metadata) > 0 {
		for k, v := range m.Metadata {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFeatures(uint64(len(k))) + 1 + len(v) + sovFeatures(uint64(len(v)))
			n += mapEntrySize + 1 + sovFeatures(uint64(mapEntrySize))
		}
	}
	if m.Feature != nil {
		n += m.Feature.Size()
	}
	return n
}

func (m *Feature_Image) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Image != nil {
		l = m.Image.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_RawImage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RawImage != nil {
		l = m.RawImage.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_Classification) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Classification != nil {
		l = m.Classification.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_BoundingBox) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BoundingBox != nil {
		l = m.BoundingBox.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_SemanticSegment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SemanticSegment != nil {
		l = m.SemanticSegment.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_InstanceSegment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InstanceSegment != nil {
		l = m.InstanceSegment.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_Text) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Text != nil {
		l = m.Text.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_Region) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Region != nil {
		l = m.Region.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_Audio) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Audio != nil {
		l = m.Audio.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_Geolocation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Geolocation != nil {
		l = m.Geolocation.Size()
		n += 1 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_General) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.General != nil {
		l = m.General.Size()
		n += 2 + l + sovFeatures(uint64(l))
	}
	return n
}
func (m *Feature_Raw) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Raw != nil {
		l = m.Raw.Size()
		n += 2 + l + sovFeatures(uint64(l))
	}
	return n
}

func sovFeatures(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozFeatures(x uint64) (n int) {
	return sovFeatures(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Image) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Image{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RawImage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RawImage{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`DataType:` + fmt.Sprintf("%v", this.DataType) + `,`,
		`CharList:` + fmt.Sprintf("%v", this.CharList) + `,`,
		`FloatList:` + fmt.Sprintf("%v", this.FloatList) + `,`,
		`Width:` + fmt.Sprintf("%v", this.Width) + `,`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`Channels:` + fmt.Sprintf("%v", this.Channels) + `,`,
		`CompressedData:` + fmt.Sprintf("%v", this.CompressedData) + `,`,
		`JpegData:` + fmt.Sprintf("%v", this.JpegData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Classification) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Classification{`,
		`Index:` + fmt.Sprintf("%v", this.Index) + `,`,
		`Label:` + fmt.Sprintf("%v", this.Label) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BoundingBox) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BoundingBox{`,
		`Index:` + fmt.Sprintf("%v", this.Index) + `,`,
		`Label:` + fmt.Sprintf("%v", this.Label) + `,`,
		`Xmin:` + fmt.Sprintf("%v", this.Xmin) + `,`,
		`Xmax:` + fmt.Sprintf("%v", this.Xmax) + `,`,
		`Ymin:` + fmt.Sprintf("%v", this.Ymin) + `,`,
		`Ymax:` + fmt.Sprintf("%v", this.Ymax) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SemanticSegment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SemanticSegment{`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`Width:` + fmt.Sprintf("%v", this.Width) + `,`,
		`IntMask:` + fmt.Sprintf("%v", this.IntMask) + `,`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`}`,
	}, "")
	return s
}
func (this *InstanceSegment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&InstanceSegment{`,
		`Index:` + fmt.Sprintf("%v", this.Index) + `,`,
		`Label:` + fmt.Sprintf("%v", this.Label) + `,`,
		`Xmin:` + fmt.Sprintf("%v", this.Xmin) + `,`,
		`Xmax:` + fmt.Sprintf("%v", this.Xmax) + `,`,
		`Ymin:` + fmt.Sprintf("%v", this.Ymin) + `,`,
		`Ymax:` + fmt.Sprintf("%v", this.Ymax) + `,`,
		`MaskType:` + fmt.Sprintf("%v", this.MaskType) + `,`,
		`Height:` + fmt.Sprintf("%v", this.Height) + `,`,
		`Width:` + fmt.Sprintf("%v", this.Width) + `,`,
		`IntMask:` + fmt.Sprintf("%v", this.IntMask) + `,`,
		`FloatMask:` + fmt.Sprintf("%v", this.FloatMask) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GeoLocation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GeoLocation{`,
		`Index:` + fmt.Sprintf("%v", this.Index) + `,`,
		`Latitude:` + fmt.Sprintf("%v", this.Latitude) + `,`,
		`Longitude:` + fmt.Sprintf("%v", this.Longitude) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Region) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Region{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Format:` + fmt.Sprintf("%v", this.Format) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Text) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Text{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Audio) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Audio{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Format:` + fmt.Sprintf("%v", this.Format) + `,`,
		`}`,
	}, "")
	return s
}
func (this *General) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&General{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Raw) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Raw{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Format:` + fmt.Sprintf("%v", this.Format) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature) String() string {
	if this == nil {
		return "nil"
	}
	keysForMetadata := make([]string, 0, len(this.Metadata))
	for k, _ := range this.Metadata {
		keysForMetadata = append(keysForMetadata, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
	mapStringForMetadata := "map[string]string{"
	for _, k := range keysForMetadata {
		mapStringForMetadata += fmt.Sprintf("%v: %v,", k, this.Metadata[k])
	}
	mapStringForMetadata += "}"
	s := strings.Join([]string{`&Feature{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Probability:` + fmt.Sprintf("%v", this.Probability) + `,`,
		`Metadata:` + mapStringForMetadata + `,`,
		`Feature:` + fmt.Sprintf("%v", this.Feature) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Image) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Image{`,
		`Image:` + strings.Replace(fmt.Sprintf("%v", this.Image), "Image", "Image", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_RawImage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_RawImage{`,
		`RawImage:` + strings.Replace(fmt.Sprintf("%v", this.RawImage), "RawImage", "RawImage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Classification) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Classification{`,
		`Classification:` + strings.Replace(fmt.Sprintf("%v", this.Classification), "Classification", "Classification", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_BoundingBox) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_BoundingBox{`,
		`BoundingBox:` + strings.Replace(fmt.Sprintf("%v", this.BoundingBox), "BoundingBox", "BoundingBox", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_SemanticSegment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_SemanticSegment{`,
		`SemanticSegment:` + strings.Replace(fmt.Sprintf("%v", this.SemanticSegment), "SemanticSegment", "SemanticSegment", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_InstanceSegment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_InstanceSegment{`,
		`InstanceSegment:` + strings.Replace(fmt.Sprintf("%v", this.InstanceSegment), "InstanceSegment", "InstanceSegment", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Text) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Text{`,
		`Text:` + strings.Replace(fmt.Sprintf("%v", this.Text), "Text", "Text", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Region) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Region{`,
		`Region:` + strings.Replace(fmt.Sprintf("%v", this.Region), "Region", "Region", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Audio) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Audio{`,
		`Audio:` + strings.Replace(fmt.Sprintf("%v", this.Audio), "Audio", "Audio", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Geolocation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Geolocation{`,
		`Geolocation:` + strings.Replace(fmt.Sprintf("%v", this.Geolocation), "GeoLocation", "GeoLocation", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_General) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_General{`,
		`General:` + strings.Replace(fmt.Sprintf("%v", this.General), "General", "General", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Feature_Raw) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Feature_Raw{`,
		`Raw:` + strings.Replace(fmt.Sprintf("%v", this.Raw), "Raw", "Raw", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringFeatures(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Image) 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 ErrIntOverflowFeatures
			}
			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: Image: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RawImage) 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 ErrIntOverflowFeatures
			}
			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: RawImage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RawImage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.CharList = append(m.CharList, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthFeatures
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthFeatures
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.CharList) == 0 {
					m.CharList = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFeatures
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.CharList = append(m.CharList, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field CharList", wireType)
			}
		case 4:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.FloatList = append(m.FloatList, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthFeatures
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthFeatures
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.FloatList) == 0 {
					m.FloatList = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.FloatList = append(m.FloatList, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatList", wireType)
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Channels", wireType)
			}
			m.Channels = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Channels |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompressedData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompressedData = append(m.CompressedData[:0], dAtA[iNdEx:postIndex]...)
			if m.CompressedData == nil {
				m.CompressedData = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JpegData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JpegData = append(m.JpegData[:0], dAtA[iNdEx:postIndex]...)
			if m.JpegData == nil {
				m.JpegData = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BoundingBox) 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 ErrIntOverflowFeatures
			}
			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: BoundingBox: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BoundingBox: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Xmin", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Xmin = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Xmax", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Xmax = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ymin", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Ymin = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ymax", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Ymax = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SemanticSegment) 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 ErrIntOverflowFeatures
			}
			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: SemanticSegment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SemanticSegment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IntMask = append(m.IntMask, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthFeatures
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthFeatures
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.IntMask) == 0 {
					m.IntMask = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFeatures
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IntMask = append(m.IntMask, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IntMask", wireType)
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = append(m.Labels, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InstanceSegment) 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 ErrIntOverflowFeatures
			}
			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: InstanceSegment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InstanceSegment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Xmin", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Xmin = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Xmax", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Xmax = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ymin", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Ymin = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ymax", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Ymax = float32(math.Float32frombits(v))
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaskType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MaskType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IntMask = append(m.IntMask, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthFeatures
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthFeatures
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.IntMask) == 0 {
					m.IntMask = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFeatures
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IntMask = append(m.IntMask, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IntMask", wireType)
			}
		case 11:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.FloatMask = append(m.FloatMask, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthFeatures
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthFeatures
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.FloatMask) == 0 {
					m.FloatMask = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.FloatMask = append(m.FloatMask, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatMask", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GeoLocation) 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 ErrIntOverflowFeatures
			}
			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: GeoLocation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GeoLocation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Latitude = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Longitude = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Feature) 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 ErrIntOverflowFeatures
			}
			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: Feature: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Feature: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				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 ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= FeatureType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Probability", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Probability = float32(math.Float32frombits(v))
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFeatures
					}
					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 ErrIntOverflowFeatures
						}
						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 ErrInvalidLengthFeatures
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthFeatures
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFeatures
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthFeatures
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthFeatures
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFeatures(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthFeatures
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Metadata[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Image{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Image{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawImage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RawImage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_RawImage{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Classification", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Classification{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Classification{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoundingBox", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BoundingBox{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_BoundingBox{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SemanticSegment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SemanticSegment{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_SemanticSegment{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceSegment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &InstanceSegment{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_InstanceSegment{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Text{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Text{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Region{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Region{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Audio", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Audio{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Audio{v}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Geolocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GeoLocation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Geolocation{v}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field General", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &General{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_General{v}
			iNdEx = postIndex
		case 1000:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFeatures
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFeatures
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFeatures
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Raw{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Feature = &Feature_Raw{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFeatures(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFeatures
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthFeatures        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFeatures          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupFeatures = fmt.Errorf("proto: unexpected end of group")
)