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

package protomsg

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
)

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

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

type TaskLabel struct {
	Taskid string   `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
	Sdkids []string `protobuf:"bytes,2,rep,name=sdkids,proto3" json:"sdkids,omitempty"`
	Index  int32    `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_TaskLabel proto.InternalMessageInfo

func (m *TaskLabel) GetTaskid() string {
	if m != nil {
		return m.Taskid
	}
	return ""
}

func (m *TaskLabel) GetSdkids() []string {
	if m != nil {
		return m.Sdkids
	}
	return nil
}

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

type SdkMessage struct {
	Cid     string     `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
	Tasklab *TaskLabel `protobuf:"bytes,2,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
	Data    []byte     `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}

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

var xxx_messageInfo_SdkMessage proto.InternalMessageInfo

func (m *SdkMessage) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

func (m *SdkMessage) GetTasklab() *TaskLabel {
	if m != nil {
		return m.Tasklab
	}
	return nil
}

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

// Image ipc struct
type Image struct {
	Width  int32  `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
	Height int32  `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Data   []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *Image) Reset()         { *m = Image{} }
func (m *Image) String() string { return proto.CompactTextString(m) }
func (*Image) ProtoMessage()    {}
func (*Image) Descriptor() ([]byte, []int) {
	return fileDescriptor_32de24555f916688, []int{2}
}
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.MarshalTo(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) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

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

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

// struct for sdk
type Point struct {
	X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	Y int32 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
}

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

var xxx_messageInfo_Point proto.InternalMessageInfo

func (m *Point) GetX() int32 {
	if m != nil {
		return m.X
	}
	return 0
}

func (m *Point) GetY() int32 {
	if m != nil {
		return m.Y
	}
	return 0
}

type Rect struct {
	Left   int32 `protobuf:"varint,1,opt,name=left,proto3" json:"left,omitempty"`
	Top    int32 `protobuf:"varint,2,opt,name=top,proto3" json:"top,omitempty"`
	Right  int32 `protobuf:"varint,3,opt,name=right,proto3" json:"right,omitempty"`
	Bottom int32 `protobuf:"varint,4,opt,name=bottom,proto3" json:"bottom,omitempty"`
}

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

var xxx_messageInfo_Rect proto.InternalMessageInfo

func (m *Rect) GetLeft() int32 {
	if m != nil {
		return m.Left
	}
	return 0
}

func (m *Rect) GetTop() int32 {
	if m != nil {
		return m.Top
	}
	return 0
}

func (m *Rect) GetRight() int32 {
	if m != nil {
		return m.Right
	}
	return 0
}

func (m *Rect) GetBottom() int32 {
	if m != nil {
		return m.Bottom
	}
	return 0
}

type FaceAngle struct {
	Yaw        int32   `protobuf:"varint,1,opt,name=yaw,proto3" json:"yaw,omitempty"`
	Pitch      int32   `protobuf:"varint,2,opt,name=pitch,proto3" json:"pitch,omitempty"`
	Roll       int32   `protobuf:"varint,3,opt,name=roll,proto3" json:"roll,omitempty"`
	Confidence float32 `protobuf:"fixed32,4,opt,name=confidence,proto3" json:"confidence,omitempty"`
}

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

var xxx_messageInfo_FaceAngle proto.InternalMessageInfo

func (m *FaceAngle) GetYaw() int32 {
	if m != nil {
		return m.Yaw
	}
	return 0
}

func (m *FaceAngle) GetPitch() int32 {
	if m != nil {
		return m.Pitch
	}
	return 0
}

func (m *FaceAngle) GetRoll() int32 {
	if m != nil {
		return m.Roll
	}
	return 0
}

func (m *FaceAngle) GetConfidence() float32 {
	if m != nil {
		return m.Confidence
	}
	return 0
}

type ThftResult struct {
	Gender int32 `protobuf:"varint,1,opt,name=gender,proto3" json:"gender,omitempty"`
	Age    int32 `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
	Race   int32 `protobuf:"varint,3,opt,name=race,proto3" json:"race,omitempty"`
	Beauty int32 `protobuf:"varint,4,opt,name=beauty,proto3" json:"beauty,omitempty"`
	Smile  int32 `protobuf:"varint,5,opt,name=smile,proto3" json:"smile,omitempty"`
}

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

var xxx_messageInfo_ThftResult proto.InternalMessageInfo

func (m *ThftResult) GetGender() int32 {
	if m != nil {
		return m.Gender
	}
	return 0
}

func (m *ThftResult) GetAge() int32 {
	if m != nil {
		return m.Age
	}
	return 0
}

func (m *ThftResult) GetRace() int32 {
	if m != nil {
		return m.Race
	}
	return 0
}

func (m *ThftResult) GetBeauty() int32 {
	if m != nil {
		return m.Beauty
	}
	return 0
}

func (m *ThftResult) GetSmile() int32 {
	if m != nil {
		return m.Smile
	}
	return 0
}

type FacePos struct {
	RcFace     *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
	PtLeftEye  *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
	PtRightEye *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
	PtMouth    *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
	PtNose     *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
	FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
	Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
	FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
}

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

var xxx_messageInfo_FacePos proto.InternalMessageInfo

func (m *FacePos) GetRcFace() *Rect {
	if m != nil {
		return m.RcFace
	}
	return nil
}

func (m *FacePos) GetPtLeftEye() *Point {
	if m != nil {
		return m.PtLeftEye
	}
	return nil
}

func (m *FacePos) GetPtRightEye() *Point {
	if m != nil {
		return m.PtRightEye
	}
	return nil
}

func (m *FacePos) GetPtMouth() *Point {
	if m != nil {
		return m.PtMouth
	}
	return nil
}

func (m *FacePos) GetPtNose() *Point {
	if m != nil {
		return m.PtNose
	}
	return nil
}

func (m *FacePos) GetFAngle() *FaceAngle {
	if m != nil {
		return m.FAngle
	}
	return nil
}

func (m *FacePos) GetQuality() int32 {
	if m != nil {
		return m.Quality
	}
	return 0
}

func (m *FacePos) GetFacialData() []byte {
	if m != nil {
		return m.FacialData
	}
	return nil
}

type FaceInfo struct {
	RcFace     *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
	PtLeftEye  *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
	PtRightEye *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
	PtMouth    *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
	PtNose     *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
	FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
	Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
	FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
	FaceID     int64      `protobuf:"varint,9,opt,name=faceID,proto3" json:"faceID,omitempty"`
}

func (m *FaceInfo) Reset()         { *m = FaceInfo{} }
func (m *FaceInfo) String() string { return proto.CompactTextString(m) }
func (*FaceInfo) ProtoMessage()    {}
func (*FaceInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_32de24555f916688, []int{8}
}
func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FaceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FaceInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FaceInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FaceInfo.Merge(m, src)
}
func (m *FaceInfo) XXX_Size() int {
	return m.Size()
}
func (m *FaceInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_FaceInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FaceInfo proto.InternalMessageInfo

func (m *FaceInfo) GetRcFace() *Rect {
	if m != nil {
		return m.RcFace
	}
	return nil
}

func (m *FaceInfo) GetPtLeftEye() *Point {
	if m != nil {
		return m.PtLeftEye
	}
	return nil
}

func (m *FaceInfo) GetPtRightEye() *Point {
	if m != nil {
		return m.PtRightEye
	}
	return nil
}

func (m *FaceInfo) GetPtMouth() *Point {
	if m != nil {
		return m.PtMouth
	}
	return nil
}

func (m *FaceInfo) GetPtNose() *Point {
	if m != nil {
		return m.PtNose
	}
	return nil
}

func (m *FaceInfo) GetFAngle() *FaceAngle {
	if m != nil {
		return m.FAngle
	}
	return nil
}

func (m *FaceInfo) GetQuality() int32 {
	if m != nil {
		return m.Quality
	}
	return 0
}

func (m *FaceInfo) GetFacialData() []byte {
	if m != nil {
		return m.FacialData
	}
	return nil
}

func (m *FaceInfo) GetFaceID() int64 {
	if m != nil {
		return m.FaceID
	}
	return 0
}

type ObjInfo struct {
	RcObj *Rect   `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
	Typ   int32   `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Prob  float32 `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
}

func (m *ObjInfo) Reset()         { *m = ObjInfo{} }
func (m *ObjInfo) String() string { return proto.CompactTextString(m) }
func (*ObjInfo) ProtoMessage()    {}
func (*ObjInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_32de24555f916688, []int{9}
}
func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ObjInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ObjInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ObjInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ObjInfo.Merge(m, src)
}
func (m *ObjInfo) XXX_Size() int {
	return m.Size()
}
func (m *ObjInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ObjInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ObjInfo proto.InternalMessageInfo

func (m *ObjInfo) GetRcObj() *Rect {
	if m != nil {
		return m.RcObj
	}
	return nil
}

func (m *ObjInfo) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *ObjInfo) GetProb() float32 {
	if m != nil {
		return m.Prob
	}
	return 0
}

func init() {
	proto.RegisterType((*TaskLabel)(nil), "protomsg.TaskLabel")
	proto.RegisterType((*SdkMessage)(nil), "protomsg.SdkMessage")
	proto.RegisterType((*Image)(nil), "protomsg.Image")
	proto.RegisterType((*Point)(nil), "protomsg.Point")
	proto.RegisterType((*Rect)(nil), "protomsg.Rect")
	proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
	proto.RegisterType((*ThftResult)(nil), "protomsg.ThftResult")
	proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
	proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
	proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
}

func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

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

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

func (m *TaskLabel) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Taskid) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Taskid)))
		i += copy(dAtA[i:], m.Taskid)
	}
	if len(m.Sdkids) > 0 {
		for _, s := range m.Sdkids {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Index != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Index))
	}
	return i, nil
}

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

func (m *SdkMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Cid) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Cid)))
		i += copy(dAtA[i:], m.Cid)
	}
	if m.Tasklab != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Tasklab.Size()))
		n1, err1 := m.Tasklab.MarshalTo(dAtA[i:])
		if err1 != nil {
			return 0, err1
		}
		i += n1
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	return i, nil
}

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

func (m *Image) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Width != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Width))
	}
	if m.Height != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Height))
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	return i, nil
}

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

func (m *Point) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.X != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.X))
	}
	if m.Y != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Y))
	}
	return i, nil
}

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

func (m *Rect) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Left != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Left))
	}
	if m.Top != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Top))
	}
	if m.Right != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Right))
	}
	if m.Bottom != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Bottom))
	}
	return i, nil
}

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

func (m *FaceAngle) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Yaw != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Yaw))
	}
	if m.Pitch != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Pitch))
	}
	if m.Roll != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Roll))
	}
	if m.Confidence != 0 {
		dAtA[i] = 0x25
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
		i += 4
	}
	return i, nil
}

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

func (m *ThftResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Gender != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Gender))
	}
	if m.Age != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Age))
	}
	if m.Race != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Race))
	}
	if m.Beauty != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Beauty))
	}
	if m.Smile != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Smile))
	}
	return i, nil
}

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

func (m *FacePos) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RcFace != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
		n2, err2 := m.RcFace.MarshalTo(dAtA[i:])
		if err2 != nil {
			return 0, err2
		}
		i += n2
	}
	if m.PtLeftEye != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
		n3, err3 := m.PtLeftEye.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += n3
	}
	if m.PtRightEye != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
		n4, err4 := m.PtRightEye.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += n4
	}
	if m.PtMouth != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
		n5, err5 := m.PtMouth.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	if m.PtNose != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
		n6, err6 := m.PtNose.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	if m.FAngle != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
		n7, err7 := m.FAngle.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	if m.Quality != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Quality))
	}
	if len(m.FacialData) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FacialData)))
		i += copy(dAtA[i:], m.FacialData)
	}
	return i, nil
}

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

func (m *FaceInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RcFace != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
		n8, err8 := m.RcFace.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	if m.PtLeftEye != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
		n9, err9 := m.PtLeftEye.MarshalTo(dAtA[i:])
		if err9 != nil {
			return 0, err9
		}
		i += n9
	}
	if m.PtRightEye != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
		n10, err10 := m.PtRightEye.MarshalTo(dAtA[i:])
		if err10 != nil {
			return 0, err10
		}
		i += n10
	}
	if m.PtMouth != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
		n11, err11 := m.PtMouth.MarshalTo(dAtA[i:])
		if err11 != nil {
			return 0, err11
		}
		i += n11
	}
	if m.PtNose != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
		n12, err12 := m.PtNose.MarshalTo(dAtA[i:])
		if err12 != nil {
			return 0, err12
		}
		i += n12
	}
	if m.FAngle != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
		n13, err13 := m.FAngle.MarshalTo(dAtA[i:])
		if err13 != nil {
			return 0, err13
		}
		i += n13
	}
	if m.Quality != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Quality))
	}
	if len(m.FacialData) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FacialData)))
		i += copy(dAtA[i:], m.FacialData)
	}
	if m.FaceID != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.FaceID))
	}
	return i, nil
}

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

func (m *ObjInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RcObj != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.RcObj.Size()))
		n14, err14 := m.RcObj.MarshalTo(dAtA[i:])
		if err14 != nil {
			return 0, err14
		}
		i += n14
	}
	if m.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintProtomsg(dAtA, i, uint64(m.Typ))
	}
	if m.Prob != 0 {
		dAtA[i] = 0x1d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
		i += 4
	}
	return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *TaskLabel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Taskid)
	if l > 0 {
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if len(m.Sdkids) > 0 {
		for _, s := range m.Sdkids {
			l = len(s)
			n += 1 + l + sovProtomsg(uint64(l))
		}
	}
	if m.Index != 0 {
		n += 1 + sovProtomsg(uint64(m.Index))
	}
	return n
}

func (m *SdkMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Cid)
	if l > 0 {
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.Tasklab != nil {
		l = m.Tasklab.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovProtomsg(uint64(l))
	}
	return n
}

func (m *Image) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Width != 0 {
		n += 1 + sovProtomsg(uint64(m.Width))
	}
	if m.Height != 0 {
		n += 1 + sovProtomsg(uint64(m.Height))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovProtomsg(uint64(l))
	}
	return n
}

func (m *Point) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.X != 0 {
		n += 1 + sovProtomsg(uint64(m.X))
	}
	if m.Y != 0 {
		n += 1 + sovProtomsg(uint64(m.Y))
	}
	return n
}

func (m *Rect) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Left != 0 {
		n += 1 + sovProtomsg(uint64(m.Left))
	}
	if m.Top != 0 {
		n += 1 + sovProtomsg(uint64(m.Top))
	}
	if m.Right != 0 {
		n += 1 + sovProtomsg(uint64(m.Right))
	}
	if m.Bottom != 0 {
		n += 1 + sovProtomsg(uint64(m.Bottom))
	}
	return n
}

func (m *FaceAngle) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Yaw != 0 {
		n += 1 + sovProtomsg(uint64(m.Yaw))
	}
	if m.Pitch != 0 {
		n += 1 + sovProtomsg(uint64(m.Pitch))
	}
	if m.Roll != 0 {
		n += 1 + sovProtomsg(uint64(m.Roll))
	}
	if m.Confidence != 0 {
		n += 5
	}
	return n
}

func (m *ThftResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Gender != 0 {
		n += 1 + sovProtomsg(uint64(m.Gender))
	}
	if m.Age != 0 {
		n += 1 + sovProtomsg(uint64(m.Age))
	}
	if m.Race != 0 {
		n += 1 + sovProtomsg(uint64(m.Race))
	}
	if m.Beauty != 0 {
		n += 1 + sovProtomsg(uint64(m.Beauty))
	}
	if m.Smile != 0 {
		n += 1 + sovProtomsg(uint64(m.Smile))
	}
	return n
}

func (m *FacePos) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RcFace != nil {
		l = m.RcFace.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtLeftEye != nil {
		l = m.PtLeftEye.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtRightEye != nil {
		l = m.PtRightEye.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtMouth != nil {
		l = m.PtMouth.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtNose != nil {
		l = m.PtNose.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.FAngle != nil {
		l = m.FAngle.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.Quality != 0 {
		n += 1 + sovProtomsg(uint64(m.Quality))
	}
	l = len(m.FacialData)
	if l > 0 {
		n += 1 + l + sovProtomsg(uint64(l))
	}
	return n
}

func (m *FaceInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RcFace != nil {
		l = m.RcFace.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtLeftEye != nil {
		l = m.PtLeftEye.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtRightEye != nil {
		l = m.PtRightEye.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtMouth != nil {
		l = m.PtMouth.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.PtNose != nil {
		l = m.PtNose.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.FAngle != nil {
		l = m.FAngle.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.Quality != 0 {
		n += 1 + sovProtomsg(uint64(m.Quality))
	}
	l = len(m.FacialData)
	if l > 0 {
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.FaceID != 0 {
		n += 1 + sovProtomsg(uint64(m.FaceID))
	}
	return n
}

func (m *ObjInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RcObj != nil {
		l = m.RcObj.Size()
		n += 1 + l + sovProtomsg(uint64(l))
	}
	if m.Typ != 0 {
		n += 1 + sovProtomsg(uint64(m.Typ))
	}
	if m.Prob != 0 {
		n += 5
	}
	return n
}

func sovProtomsg(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozProtomsg(x uint64) (n int) {
	return sovProtomsg(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TaskLabel) 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 ErrIntOverflowProtomsg
			}
			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: TaskLabel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskLabel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taskid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				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 ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taskid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sdkids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				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 ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sdkids = append(m.Sdkids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SdkMessage) 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 ErrIntOverflowProtomsg
			}
			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: SdkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SdkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				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 ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tasklab", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tasklab == nil {
				m.Tasklab = &TaskLabel{}
			}
			if err := m.Tasklab.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			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 := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
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 ErrIntOverflowProtomsg
			}
			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 != 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 ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			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 := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Rect) 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 ErrIntOverflowProtomsg
			}
			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: Rect: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rect: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
			}
			m.Left = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Left |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Top", wireType)
			}
			m.Top = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Top |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
			}
			m.Right = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Right |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bottom", wireType)
			}
			m.Bottom = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bottom |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThftResult) 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 ErrIntOverflowProtomsg
			}
			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: ThftResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThftResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gender", wireType)
			}
			m.Gender = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gender |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
			}
			m.Age = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Age |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Race", wireType)
			}
			m.Race = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Race |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Beauty", wireType)
			}
			m.Beauty = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Beauty |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Smile", wireType)
			}
			m.Smile = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Smile |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FacePos) 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 ErrIntOverflowProtomsg
			}
			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: FacePos: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FacePos: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RcFace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RcFace == nil {
				m.RcFace = &Rect{}
			}
			if err := m.RcFace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtLeftEye", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtLeftEye == nil {
				m.PtLeftEye = &Point{}
			}
			if err := m.PtLeftEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtRightEye", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtRightEye == nil {
				m.PtRightEye = &Point{}
			}
			if err := m.PtRightEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtMouth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtMouth == nil {
				m.PtMouth = &Point{}
			}
			if err := m.PtMouth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtNose", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtNose == nil {
				m.PtNose = &Point{}
			}
			if err := m.PtNose.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FAngle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FAngle == nil {
				m.FAngle = &FaceAngle{}
			}
			if err := m.FAngle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quality", wireType)
			}
			m.Quality = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Quality |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FacialData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
			if m.FacialData == nil {
				m.FacialData = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FaceInfo) 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 ErrIntOverflowProtomsg
			}
			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: FaceInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FaceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RcFace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RcFace == nil {
				m.RcFace = &Rect{}
			}
			if err := m.RcFace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtLeftEye", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtLeftEye == nil {
				m.PtLeftEye = &Point{}
			}
			if err := m.PtLeftEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtRightEye", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtRightEye == nil {
				m.PtRightEye = &Point{}
			}
			if err := m.PtRightEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtMouth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtMouth == nil {
				m.PtMouth = &Point{}
			}
			if err := m.PtMouth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtNose", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtNose == nil {
				m.PtNose = &Point{}
			}
			if err := m.PtNose.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FAngle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FAngle == nil {
				m.FAngle = &FaceAngle{}
			}
			if err := m.FAngle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quality", wireType)
			}
			m.Quality = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Quality |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FacialData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
			if m.FacialData == nil {
				m.FacialData = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FaceID", wireType)
			}
			m.FaceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtomsg
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FaceID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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