pubsub/protomsg.git

			@@ -6,7 +6,7 @@
			import (
			encoding_binary "encoding/binary"
			fmt "fmt"
			proto "github.com/golang/protobuf/proto"
			proto "github.com/gogo/protobuf/proto"
			io "io"
			math "math"
			)
			@@ -20,16 +20,19 @@
			// 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.ProtoPackageIsVersion2 // please upgrade the proto package
			const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

			// 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"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			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"`
			Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
			Id int64 `protobuf:"varint,5,opt,name=id,proto3" json:"id,omitempty"`
			Cid string `protobuf:"bytes,6,opt,name=cid,proto3" json:"cid,omitempty"`
			Cname string `protobuf:"bytes,7,opt,name=cname,proto3" json:"cname,omitempty"`
			Channel int32 `protobuf:"varint,8,opt,name=channel,proto3" json:"channel,omitempty"`
			I64Timestamp int64 `protobuf:"varint,9,opt,name=i64timestamp,proto3" json:"i64timestamp,omitempty"`
			}

			func (m Image) Reset() { m = Image{} }
			@@ -86,21 +89,280 @@
			return nil
			}

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

			func (m *Image) GetId() int64 {
			if m != nil {
			return m.Id
			}
			return 0
			}

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

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

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

			func (m *Image) GetI64Timestamp() int64 {
			if m != nil {
			return m.I64Timestamp
			}
			return 0
			}

			type Target struct {
			Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
			Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
			Confidence int32 `protobuf:"varint,3,opt,name=confidence,proto3" json:"confidence,omitempty"`
			Rect *Rect `protobuf:"bytes,4,opt,name=rect,proto3" json:"rect,omitempty"`
			Feature []byte `protobuf:"bytes,5,opt,name=feature,proto3" json:"feature,omitempty"`
			Attribute []byte `protobuf:"bytes,6,opt,name=attribute,proto3" json:"attribute,omitempty"`
			}

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

			var xxx_messageInfo_Target proto.InternalMessageInfo

			func (m *Target) GetId() uint64 {
			if m != nil {
			return m.Id
			}
			return 0
			}

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

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

			func (m Target) GetRect() Rect {
			if m != nil {
			return m.Rect
			}
			return nil
			}

			func (m *Target) GetFeature() []byte {
			if m != nil {
			return m.Feature
			}
			return nil
			}

			func (m *Target) GetAttribute() []byte {
			if m != nil {
			return m.Attribute
			}
			return nil
			}

			type NewSDKMessage struct {
			SdkID string `protobuf:"bytes,1,opt,name=sdkID,proto3" json:"sdkID,omitempty"`
			SdkType string `protobuf:"bytes,2,opt,name=sdkType,proto3" json:"sdkType,omitempty"`
			SdkName string `protobuf:"bytes,3,opt,name=sdkName,proto3" json:"sdkName,omitempty"`
			Target []*Target `protobuf:"bytes,4,rep,name=target,proto3" json:"target,omitempty"`
			Timestamp string `protobuf:"bytes,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
			}

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

			var xxx_messageInfo_NewSDKMessage proto.InternalMessageInfo

			func (m *NewSDKMessage) GetSdkID() string {
			if m != nil {
			return m.SdkID
			}
			return ""
			}

			func (m *NewSDKMessage) GetSdkType() string {
			if m != nil {
			return m.SdkType
			}
			return ""
			}

			func (m *NewSDKMessage) GetSdkName() string {
			if m != nil {
			return m.SdkName
			}
			return ""
			}

			func (m NewSDKMessage) GetTarget() []Target {
			if m != nil {
			return m.Target
			}
			return nil
			}

			func (m *NewSDKMessage) GetTimestamp() string {
			if m != nil {
			return m.Timestamp
			}
			return ""
			}

			type NewRuleMessage struct {
			DataType string `protobuf:"bytes,1,opt,name=dataType,proto3" json:"dataType,omitempty"`
			HandleTrack string `protobuf:"bytes,2,opt,name=handleTrack,proto3" json:"handleTrack,omitempty"`
			Message []*NewSDKMessage `protobuf:"bytes,3,rep,name=message,proto3" json:"message,omitempty"`
			}

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

			var xxx_messageInfo_NewRuleMessage proto.InternalMessageInfo

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

			func (m *NewRuleMessage) GetHandleTrack() string {
			if m != nil {
			return m.HandleTrack
			}
			return ""
			}

			func (m NewRuleMessage) GetMessage() []NewSDKMessage {
			if m != nil {
			return m.Message
			}
			return nil
			}

			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"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			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_70decb0fb6f436df, []int{1}
			return fileDescriptor_70decb0fb6f436df, []int{4}
			}
			func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -158,21 +420,18 @@
			}

			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"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			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_70decb0fb6f436df, []int{2}
			return fileDescriptor_70decb0fb6f436df, []int{5}
			}
			func (m *ThftResult) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -237,24 +496,22 @@
			}

			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"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			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 uint64 `protobuf:"varint,9,opt,name=faceID,proto3" json:"faceID,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_70decb0fb6f436df, []int{3}
			return fileDescriptor_70decb0fb6f436df, []int{6}
			}
			func (m *FacePos) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -339,26 +596,30 @@
			return nil
			}

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

			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"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			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_70decb0fb6f436df, []int{4}
			return fileDescriptor_70decb0fb6f436df, []int{7}
			}
			func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -451,19 +712,17 @@
			}

			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"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			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"`
			ObjID uint64 `protobuf:"varint,4,opt,name=objID,proto3" json:"objID,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_70decb0fb6f436df, []int{5}
			return fileDescriptor_70decb0fb6f436df, []int{8}
			}
			func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -513,21 +772,83 @@
			return 0
			}

			func (m *ObjInfo) GetObjID() uint64 {
			if m != nil {
			return m.ObjID
			}
			return 0
			}

			// sdk face property
			type ResultFaceDetect struct {
			Pos *FacePos `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
			Result *ThftResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
			Feats []byte `protobuf:"bytes,3,opt,name=feats,proto3" json:"feats,omitempty"`
			}

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

			var xxx_messageInfo_ResultFaceDetect proto.InternalMessageInfo

			func (m ResultFaceDetect) GetPos() FacePos {
			if m != nil {
			return m.Pos
			}
			return nil
			}

			func (m ResultFaceDetect) GetResult() ThftResult {
			if m != nil {
			return m.Result
			}
			return nil
			}

			func (m *ResultFaceDetect) GetFeats() []byte {
			if m != nil {
			return m.Feats
			}
			return nil
			}

			type ParamFacePos struct {
			Pos *FacePos `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
			Result *ThftResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
			Img *Image `protobuf:"bytes,3,opt,name=img,proto3" json:"img,omitempty"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			Faces []*ResultFaceDetect `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
			}

			func (m ParamFacePos) Reset() { m = ParamFacePos{} }
			func (m *ParamFacePos) String() string { return proto.CompactTextString(m) }
			func (*ParamFacePos) ProtoMessage() {}
			func (*ParamFacePos) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{6}
			return fileDescriptor_70decb0fb6f436df, []int{10}
			}
			func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -556,48 +877,31 @@

			var xxx_messageInfo_ParamFacePos proto.InternalMessageInfo

			func (m ParamFacePos) GetPos() FacePos {
			func (m ParamFacePos) GetFaces() []ResultFaceDetect {
			if m != nil {
			return m.Pos
			return m.Faces
			}
			return nil
			}

			func (m ParamFacePos) GetResult() ThftResult {
			if m != nil {
			return m.Result
			}
			return nil
			type ResultFaceExtCom struct {
			Feats []byte `protobuf:"bytes,1,opt,name=feats,proto3" json:"feats,omitempty"`
			Comp []byte `protobuf:"bytes,2,opt,name=comp,proto3" json:"comp,omitempty"`
			Pos *ResultFaceDetect `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
			}

			func (m ParamFacePos) GetImg() Image {
			if m != nil {
			return m.Img
			}
			return nil
			func (m ResultFaceExtCom) Reset() { m = ResultFaceExtCom{} }
			func (m *ResultFaceExtCom) String() string { return proto.CompactTextString(m) }
			func (*ResultFaceExtCom) ProtoMessage() {}
			func (*ResultFaceExtCom) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{11}
			}

			// sdk face extract
			type ParamFaceCompare struct {
			Feat1 []byte `protobuf:"bytes,1,opt,name=feat1,proto3" json:"feat1,omitempty"`
			Feat2 []byte `protobuf:"bytes,2,opt,name=feat2,proto3" json:"feat2,omitempty"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			}

			func (m ParamFaceCompare) Reset() { m = ParamFaceCompare{} }
			func (m *ParamFaceCompare) String() string { return proto.CompactTextString(m) }
			func (*ParamFaceCompare) ProtoMessage() {}
			func (*ParamFaceCompare) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{7}
			}
			func (m *ParamFaceCompare) XXX_Unmarshal(b []byte) error {
			func (m *ResultFaceExtCom) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			}
			func (m *ParamFaceCompare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
			func (m *ResultFaceExtCom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
			if deterministic {
			return xxx_messageInfo_ParamFaceCompare.Marshal(b, m, deterministic)
			return xxx_messageInfo_ResultFaceExtCom.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalTo(b)
			@@ -607,46 +911,93 @@
			return b[:n], nil
			}
			}
			func (m *ParamFaceCompare) XXX_Merge(src proto.Message) {
			xxx_messageInfo_ParamFaceCompare.Merge(m, src)
			func (m *ResultFaceExtCom) XXX_Merge(src proto.Message) {
			xxx_messageInfo_ResultFaceExtCom.Merge(m, src)
			}
			func (m *ParamFaceCompare) XXX_Size() int {
			func (m *ResultFaceExtCom) XXX_Size() int {
			return m.Size()
			}
			func (m *ParamFaceCompare) XXX_DiscardUnknown() {
			xxx_messageInfo_ParamFaceCompare.DiscardUnknown(m)
			func (m *ResultFaceExtCom) XXX_DiscardUnknown() {
			xxx_messageInfo_ResultFaceExtCom.DiscardUnknown(m)
			}

			var xxx_messageInfo_ParamFaceCompare proto.InternalMessageInfo
			var xxx_messageInfo_ResultFaceExtCom proto.InternalMessageInfo

			func (m *ParamFaceCompare) GetFeat1() []byte {
			func (m *ResultFaceExtCom) GetFeats() []byte {
			if m != nil {
			return m.Feat1
			return m.Feats
			}
			return nil
			}

			func (m *ParamFaceCompare) GetFeat2() []byte {
			func (m *ResultFaceExtCom) GetComp() []byte {
			if m != nil {
			return m.Feat2
			return m.Comp
			}
			return nil
			}

			func (m ResultFaceExtCom) GetPos() ResultFaceDetect {
			if m != nil {
			return m.Pos
			}
			return nil
			}

			type ParamFaceFeature struct {
			ExtComp []*ResultFaceExtCom `protobuf:"bytes,2,rep,name=extComp,proto3" json:"extComp,omitempty"`
			}

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

			var xxx_messageInfo_ParamFaceFeature proto.InternalMessageInfo

			func (m ParamFaceFeature) GetExtComp() []ResultFaceExtCom {
			if m != nil {
			return m.ExtComp
			}
			return nil
			}

			// sdk yolo detect
			type ParamYoloObj struct {
			Infos []*ObjInfo `protobuf:"bytes,1,rep,name=infos,proto3" json:"infos,omitempty"`
			Img *Image `protobuf:"bytes,2,opt,name=img,proto3" json:"img,omitempty"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			Infos []*ObjInfo `protobuf:"bytes,1,rep,name=infos,proto3" json:"infos,omitempty"`
			}

			func (m ParamYoloObj) Reset() { m = ParamYoloObj{} }
			func (m *ParamYoloObj) String() string { return proto.CompactTextString(m) }
			func (*ParamYoloObj) ProtoMessage() {}
			func (*ParamYoloObj) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{8}
			return fileDescriptor_70decb0fb6f436df, []int{13}
			}
			func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -682,66 +1033,885 @@
			return nil
			}

			func (m ParamYoloObj) GetImg() Image {
			type SoInfo struct {
			Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
			SdkId string `protobuf:"bytes,2,opt,name=sdkId,proto3" json:"sdkId,omitempty"`
			SoName string `protobuf:"bytes,3,opt,name=soName,proto3" json:"soName,omitempty"`
			}

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

			var xxx_messageInfo_SoInfo proto.InternalMessageInfo

			func (m *SoInfo) GetId() string {
			if m != nil {
			return m.Img
			return m.Id
			}
			return ""
			}

			func (m *SoInfo) GetSdkId() string {
			if m != nil {
			return m.SdkId
			}
			return ""
			}

			func (m *SoInfo) GetSoName() string {
			if m != nil {
			return m.SoName
			}
			return ""
			}

			// sdk plate id detect
			type PlateID struct {
			License string `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
			Color string `protobuf:"bytes,2,opt,name=color,proto3" json:"color,omitempty"`
			NColor int32 `protobuf:"varint,3,opt,name=nColor,proto3" json:"nColor,omitempty"`
			NType int32 `protobuf:"varint,4,opt,name=nType,proto3" json:"nType,omitempty"`
			NConfidence int32 `protobuf:"varint,5,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
			NBright int32 `protobuf:"varint,6,opt,name=nBright,proto3" json:"nBright,omitempty"`
			NDirection int32 `protobuf:"varint,7,opt,name=nDirection,proto3" json:"nDirection,omitempty"`
			RcLocation *Rect `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
			NTime int32 `protobuf:"varint,9,opt,name=nTime,proto3" json:"nTime,omitempty"`
			NCarBright int32 `protobuf:"varint,10,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
			NCarColor int32 `protobuf:"varint,11,opt,name=NCarColor,proto3" json:"NCarColor,omitempty"`
			NCarLogo int32 `protobuf:"varint,12,opt,name=nCarLogo,proto3" json:"nCarLogo,omitempty"`
			NCarType int32 `protobuf:"varint,13,opt,name=nCarType,proto3" json:"nCarType,omitempty"`
			PlateBin []byte `protobuf:"bytes,14,opt,name=plateBin,proto3" json:"plateBin,omitempty"`
			NBinPlateWidth []byte `protobuf:"bytes,15,opt,name=nBinPlateWidth,proto3" json:"nBinPlateWidth,omitempty"`
			NBinPlateHeight []byte `protobuf:"bytes,16,opt,name=nBinPlateHeight,proto3" json:"nBinPlateHeight,omitempty"`
			RcLogoLocation *Rect `protobuf:"bytes,17,opt,name=rcLogoLocation,proto3" json:"rcLogoLocation,omitempty"`
			NCarModel []byte `protobuf:"bytes,18,opt,name=nCarModel,proto3" json:"nCarModel,omitempty"`
			NCarModelConfidence []byte `protobuf:"bytes,19,opt,name=nCarModelConfidence,proto3" json:"nCarModelConfidence,omitempty"`
			}

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

			var xxx_messageInfo_PlateID proto.InternalMessageInfo

			func (m *PlateID) GetLicense() string {
			if m != nil {
			return m.License
			}
			return ""
			}

			func (m *PlateID) GetColor() string {
			if m != nil {
			return m.Color
			}
			return ""
			}

			func (m *PlateID) GetNColor() int32 {
			if m != nil {
			return m.NColor
			}
			return 0
			}

			func (m *PlateID) GetNType() int32 {
			if m != nil {
			return m.NType
			}
			return 0
			}

			func (m *PlateID) GetNConfidence() int32 {
			if m != nil {
			return m.NConfidence
			}
			return 0
			}

			func (m *PlateID) GetNBright() int32 {
			if m != nil {
			return m.NBright
			}
			return 0
			}

			func (m *PlateID) GetNDirection() int32 {
			if m != nil {
			return m.NDirection
			}
			return 0
			}

			func (m PlateID) GetRcLocation() Rect {
			if m != nil {
			return m.RcLocation
			}
			return nil
			}

			func (m *PlateID) GetNTime() int32 {
			if m != nil {
			return m.NTime
			}
			return 0
			}

			func (m *PlateID) GetNCarBright() int32 {
			if m != nil {
			return m.NCarBright
			}
			return 0
			}

			func (m *PlateID) GetNCarColor() int32 {
			if m != nil {
			return m.NCarColor
			}
			return 0
			}

			func (m *PlateID) GetNCarLogo() int32 {
			if m != nil {
			return m.NCarLogo
			}
			return 0
			}

			func (m *PlateID) GetNCarType() int32 {
			if m != nil {
			return m.NCarType
			}
			return 0
			}

			func (m *PlateID) GetPlateBin() []byte {
			if m != nil {
			return m.PlateBin
			}
			return nil
			}

			func (m *PlateID) GetNBinPlateWidth() []byte {
			if m != nil {
			return m.NBinPlateWidth
			}
			return nil
			}

			func (m *PlateID) GetNBinPlateHeight() []byte {
			if m != nil {
			return m.NBinPlateHeight
			}
			return nil
			}

			func (m PlateID) GetRcLogoLocation() Rect {
			if m != nil {
			return m.RcLogoLocation
			}
			return nil
			}

			func (m *PlateID) GetNCarModel() []byte {
			if m != nil {
			return m.NCarModel
			}
			return nil
			}

			func (m *PlateID) GetNCarModelConfidence() []byte {
			if m != nil {
			return m.NCarModelConfidence
			}
			return nil
			}

			// cloud
			type PlateIDCloud struct {
			License string `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
			RcLocation *Rect `protobuf:"bytes,2,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
			NConfidence int32 `protobuf:"varint,3,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
			NType int32 `protobuf:"varint,4,opt,name=nType,proto3" json:"nType,omitempty"`
			NDirection int32 `protobuf:"varint,5,opt,name=nDirection,proto3" json:"nDirection,omitempty"`
			NCarColor int32 `protobuf:"varint,6,opt,name=nCarColor,proto3" json:"nCarColor,omitempty"`
			NCarColor1 int32 `protobuf:"varint,7,opt,name=nCarColor1,proto3" json:"nCarColor1,omitempty"`
			NCarBright int32 `protobuf:"varint,8,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
			FrameNo int32 `protobuf:"varint,9,opt,name=frameNo,proto3" json:"frameNo,omitempty"`
			FaceWidth int32 `protobuf:"varint,10,opt,name=faceWidth,proto3" json:"faceWidth,omitempty"`
			FaceHeight int32 `protobuf:"varint,11,opt,name=faceHeight,proto3" json:"faceHeight,omitempty"`
			GrayFaceFlag int32 `protobuf:"varint,12,opt,name=grayFaceFlag,proto3" json:"grayFaceFlag,omitempty"`
			CharNum int32 `protobuf:"varint,13,opt,name=charNum,proto3" json:"charNum,omitempty"`
			}

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

			var xxx_messageInfo_PlateIDCloud proto.InternalMessageInfo

			func (m *PlateIDCloud) GetLicense() string {
			if m != nil {
			return m.License
			}
			return ""
			}

			func (m PlateIDCloud) GetRcLocation() Rect {
			if m != nil {
			return m.RcLocation
			}
			return nil
			}

			func (m *PlateIDCloud) GetNConfidence() int32 {
			if m != nil {
			return m.NConfidence
			}
			return 0
			}

			func (m *PlateIDCloud) GetNType() int32 {
			if m != nil {
			return m.NType
			}
			return 0
			}

			func (m *PlateIDCloud) GetNDirection() int32 {
			if m != nil {
			return m.NDirection
			}
			return 0
			}

			func (m *PlateIDCloud) GetNCarColor() int32 {
			if m != nil {
			return m.NCarColor
			}
			return 0
			}

			func (m *PlateIDCloud) GetNCarColor1() int32 {
			if m != nil {
			return m.NCarColor1
			}
			return 0
			}

			func (m *PlateIDCloud) GetNCarBright() int32 {
			if m != nil {
			return m.NCarBright
			}
			return 0
			}

			func (m *PlateIDCloud) GetFrameNo() int32 {
			if m != nil {
			return m.FrameNo
			}
			return 0
			}

			func (m *PlateIDCloud) GetFaceWidth() int32 {
			if m != nil {
			return m.FaceWidth
			}
			return 0
			}

			func (m *PlateIDCloud) GetFaceHeight() int32 {
			if m != nil {
			return m.FaceHeight
			}
			return 0
			}

			func (m *PlateIDCloud) GetGrayFaceFlag() int32 {
			if m != nil {
			return m.GrayFaceFlag
			}
			return 0
			}

			func (m *PlateIDCloud) GetCharNum() int32 {
			if m != nil {
			return m.CharNum
			}
			return 0
			}

			type PlateIDVehicle struct {
			NPlateFlag int32 `protobuf:"varint,1,opt,name=nPlateFlag,proto3" json:"nPlateFlag,omitempty"`
			NColor int32 `protobuf:"varint,2,opt,name=nColor,proto3" json:"nColor,omitempty"`
			NType int32 `protobuf:"varint,3,opt,name=nType,proto3" json:"nType,omitempty"`
			License string `protobuf:"bytes,4,opt,name=license,proto3" json:"license,omitempty"`
			NConfidence int32 `protobuf:"varint,5,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
			NCharNum int32 `protobuf:"varint,6,opt,name=nCharNum,proto3" json:"nCharNum,omitempty"`
			NCharConfidence []int32 `protobuf:"varint,7,rep,packed,name=nCharConfidence,proto3" json:"nCharConfidence,omitempty"`
			RcLocation *Rect `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
			RcCarLocation *Rect `protobuf:"bytes,9,opt,name=rcCarLocation,proto3" json:"rcCarLocation,omitempty"`
			VehicleType string `protobuf:"bytes,10,opt,name=vehicleType,proto3" json:"vehicleType,omitempty"`
			VehicleBrand string `protobuf:"bytes,11,opt,name=vehicleBrand,proto3" json:"vehicleBrand,omitempty"`
			VehicleSub string `protobuf:"bytes,12,opt,name=vehicleSub,proto3" json:"vehicleSub,omitempty"`
			VehicleType1 string `protobuf:"bytes,13,opt,name=vehicleType1,proto3" json:"vehicleType1,omitempty"`
			FvdConf float32 `protobuf:"fixed32,14,opt,name=fvdConf,proto3" json:"fvdConf,omitempty"`
			FConfdence float32 `protobuf:"fixed32,15,opt,name=fConfdence,proto3" json:"fConfdence,omitempty"`
			NVehicleSubModel int32 `protobuf:"varint,16,opt,name=nVehicleSubModel,proto3" json:"nVehicleSubModel,omitempty"`
			NVehicleBright int32 `protobuf:"varint,17,opt,name=nVehicleBright,proto3" json:"nVehicleBright,omitempty"`
			NVehicleColor1 int32 `protobuf:"varint,18,opt,name=nVehicleColor1,proto3" json:"nVehicleColor1,omitempty"`
			NVehicleColor2 int32 `protobuf:"varint,19,opt,name=nVehicleColor2,proto3" json:"nVehicleColor2,omitempty"`
			}

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

			var xxx_messageInfo_PlateIDVehicle proto.InternalMessageInfo

			func (m *PlateIDVehicle) GetNPlateFlag() int32 {
			if m != nil {
			return m.NPlateFlag
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNColor() int32 {
			if m != nil {
			return m.NColor
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNType() int32 {
			if m != nil {
			return m.NType
			}
			return 0
			}

			func (m *PlateIDVehicle) GetLicense() string {
			if m != nil {
			return m.License
			}
			return ""
			}

			func (m *PlateIDVehicle) GetNConfidence() int32 {
			if m != nil {
			return m.NConfidence
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNCharNum() int32 {
			if m != nil {
			return m.NCharNum
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNCharConfidence() []int32 {
			if m != nil {
			return m.NCharConfidence
			}
			return nil
			}

			func (m PlateIDVehicle) GetRcLocation() Rect {
			if m != nil {
			return m.RcLocation
			}
			return nil
			}

			func (m PlateIDVehicle) GetRcCarLocation() Rect {
			if m != nil {
			return m.RcCarLocation
			}
			return nil
			}

			func (m *PlateIDVehicle) GetVehicleType() string {
			if m != nil {
			return m.VehicleType
			}
			return ""
			}

			func (m *PlateIDVehicle) GetVehicleBrand() string {
			if m != nil {
			return m.VehicleBrand
			}
			return ""
			}

			func (m *PlateIDVehicle) GetVehicleSub() string {
			if m != nil {
			return m.VehicleSub
			}
			return ""
			}

			func (m *PlateIDVehicle) GetVehicleType1() string {
			if m != nil {
			return m.VehicleType1
			}
			return ""
			}

			func (m *PlateIDVehicle) GetFvdConf() float32 {
			if m != nil {
			return m.FvdConf
			}
			return 0
			}

			func (m *PlateIDVehicle) GetFConfdence() float32 {
			if m != nil {
			return m.FConfdence
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNVehicleSubModel() int32 {
			if m != nil {
			return m.NVehicleSubModel
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNVehicleBright() int32 {
			if m != nil {
			return m.NVehicleBright
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNVehicleColor1() int32 {
			if m != nil {
			return m.NVehicleColor1
			}
			return 0
			}

			func (m *PlateIDVehicle) GetNVehicleColor2() int32 {
			if m != nil {
			return m.NVehicleColor2
			}
			return 0
			}

			type PlateIDResult struct {
			// repeated PlateID result = 1;
			// repeated PlateIDCloud result = 1;
			Result []*PlateIDVehicle `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
			}

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

			var xxx_messageInfo_PlateIDResult proto.InternalMessageInfo

			func (m PlateIDResult) GetResult() []PlateIDVehicle {
			if m != nil {
			return m.Result
			}
			return nil
			}

			type HumanTrack struct {
			RcHuman *Rect `protobuf:"bytes,1,opt,name=rcHuman,proto3" json:"rcHuman,omitempty"`
			Confidence float32 `protobuf:"fixed32,2,opt,name=confidence,proto3" json:"confidence,omitempty"`
			X int32 `protobuf:"varint,3,opt,name=x,proto3" json:"x,omitempty"`
			Y int32 `protobuf:"varint,4,opt,name=y,proto3" json:"y,omitempty"`
			Id int32 `protobuf:"varint,5,opt,name=id,proto3" json:"id,omitempty"`
			Feature []float32 `protobuf:"fixed32,6,rep,packed,name=feature,proto3" json:"feature,omitempty"`
			}

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

			var xxx_messageInfo_HumanTrack proto.InternalMessageInfo

			func (m HumanTrack) GetRcHuman() Rect {
			if m != nil {
			return m.RcHuman
			}
			return nil
			}

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

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

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

			func (m *HumanTrack) GetId() int32 {
			if m != nil {
			return m.Id
			}
			return 0
			}

			func (m *HumanTrack) GetFeature() []float32 {
			if m != nil {
			return m.Feature
			}
			return nil
			}

			type HumanTrackResult struct {
			Result []*HumanTrack `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
			}

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

			var xxx_messageInfo_HumanTrackResult proto.InternalMessageInfo

			func (m HumanTrackResult) GetResult() []HumanTrack {
			if m != nil {
			return m.Result
			}
			return nil
			}

			func init() {
			proto.RegisterType((*Image)(nil), "protomsg.Image")
			proto.RegisterType((*Target)(nil), "protomsg.Target")
			proto.RegisterType((*NewSDKMessage)(nil), "protomsg.NewSDKMessage")
			proto.RegisterType((*NewRuleMessage)(nil), "protomsg.NewRuleMessage")
			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")
			proto.RegisterType((*ResultFaceDetect)(nil), "protomsg.ResultFaceDetect")
			proto.RegisterType((*ParamFacePos)(nil), "protomsg.ParamFacePos")
			proto.RegisterType((*ParamFaceCompare)(nil), "protomsg.ParamFaceCompare")
			proto.RegisterType((*ResultFaceExtCom)(nil), "protomsg.ResultFaceExtCom")
			proto.RegisterType((*ParamFaceFeature)(nil), "protomsg.ParamFaceFeature")
			proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
			proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
			proto.RegisterType((*PlateID)(nil), "protomsg.PlateID")
			proto.RegisterType((*PlateIDCloud)(nil), "protomsg.PlateIDCloud")
			proto.RegisterType((*PlateIDVehicle)(nil), "protomsg.PlateIDVehicle")
			proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
			proto.RegisterType((*HumanTrack)(nil), "protomsg.HumanTrack")
			proto.RegisterType((*HumanTrackResult)(nil), "protomsg.HumanTrackResult")
			}

			func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

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

			func (m *Image) Marshal() (dAtA []byte, err error) {
			@@ -775,8 +1945,190 @@
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Data)))
			i += copy(dAtA[i:], m.Data)
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			if len(m.Timestamp) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Timestamp)))
			i += copy(dAtA[i:], m.Timestamp)
			}
			if m.Id != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Id))
			}
			if len(m.Cid) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Cid)))
			i += copy(dAtA[i:], m.Cid)
			}
			if len(m.Cname) > 0 {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Cname)))
			i += copy(dAtA[i:], m.Cname)
			}
			if m.Channel != 0 {
			dAtA[i] = 0x40
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Channel))
			}
			if m.I64Timestamp != 0 {
			dAtA[i] = 0x48
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.I64Timestamp))
			}
			return i, nil
			}

			func (m *Target) 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 *Target) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.Id != 0 {
			dAtA[i] = 0x8
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Id))
			}
			if len(m.Type) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Type)))
			i += copy(dAtA[i:], m.Type)
			}
			if m.Confidence != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Confidence))
			}
			if m.Rect != nil {
			dAtA[i] = 0x22
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Rect.Size()))
			n1, err1 := m.Rect.MarshalTo(dAtA[i:])
			if err1 != nil {
			return 0, err1
			}
			i += n1
			}
			if len(m.Feature) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feature)))
			i += copy(dAtA[i:], m.Feature)
			}
			if len(m.Attribute) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Attribute)))
			i += copy(dAtA[i:], m.Attribute)
			}
			return i, nil
			}

			func (m *NewSDKMessage) 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 *NewSDKMessage) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.SdkID) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkID)))
			i += copy(dAtA[i:], m.SdkID)
			}
			if len(m.SdkType) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkType)))
			i += copy(dAtA[i:], m.SdkType)
			}
			if len(m.SdkName) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkName)))
			i += copy(dAtA[i:], m.SdkName)
			}
			if len(m.Target) > 0 {
			for _, msg := range m.Target {
			dAtA[i] = 0x22
			i++
			i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			if len(m.Timestamp) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Timestamp)))
			i += copy(dAtA[i:], m.Timestamp)
			}
			return i, nil
			}

			func (m *NewRuleMessage) 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 *NewRuleMessage) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.DataType) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.DataType)))
			i += copy(dAtA[i:], m.DataType)
			}
			if len(m.HandleTrack) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.HandleTrack)))
			i += copy(dAtA[i:], m.HandleTrack)
			}
			if len(m.Message) > 0 {
			for _, msg := range m.Message {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			return i, nil
			}
			@@ -816,9 +2168,6 @@
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
			i += 4
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}
			@@ -863,9 +2212,6 @@
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Smile))
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			@@ -888,61 +2234,61 @@
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcFace.Size()))
			n1, err1 := m.RcFace.MarshalTo(dAtA[i:])
			if err1 != nil {
			return 0, err1
			}
			i += n1
			}
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtLeftEye.Size()))
			n2, err2 := m.PtLeftEye.MarshalTo(dAtA[i:])
			n2, err2 := m.RcFace.MarshalTo(dAtA[i:])
			if err2 != nil {
			return 0, err2
			}
			i += n2
			}
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
			n3, err3 := m.PtRightEye.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(dAtA, i, uint64(m.PtLeftEye.Size()))
			n3, err3 := m.PtLeftEye.MarshalTo(dAtA[i:])
			if err3 != nil {
			return 0, err3
			}
			i += n3
			}
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
			n4, err4 := m.PtMouth.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
			n4, err4 := m.PtRightEye.MarshalTo(dAtA[i:])
			if err4 != nil {
			return 0, err4
			}
			i += n4
			}
			if m.PtNose != nil {
			dAtA[i] = 0x2a
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtNose.Size()))
			n5, err5 := m.PtNose.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
			n5, err5 := m.PtMouth.MarshalTo(dAtA[i:])
			if err5 != nil {
			return 0, err5
			}
			i += n5
			}
			if m.FAngle != nil {
			dAtA[i] = 0x32
			if m.PtNose != nil {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FAngle.Size()))
			n6, err6 := m.FAngle.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(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 = encodeVarintSdk(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
			@@ -955,8 +2301,10 @@
			i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
			i += copy(dAtA[i:], m.FacialData)
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			if m.FaceID != 0 {
			dAtA[i] = 0x48
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
			}
			return i, nil
			}
			@@ -980,61 +2328,61 @@
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcFace.Size()))
			n7, err7 := m.RcFace.MarshalTo(dAtA[i:])
			if err7 != nil {
			return 0, err7
			}
			i += n7
			}
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtLeftEye.Size()))
			n8, err8 := m.PtLeftEye.MarshalTo(dAtA[i:])
			n8, err8 := m.RcFace.MarshalTo(dAtA[i:])
			if err8 != nil {
			return 0, err8
			}
			i += n8
			}
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
			n9, err9 := m.PtRightEye.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(dAtA, i, uint64(m.PtLeftEye.Size()))
			n9, err9 := m.PtLeftEye.MarshalTo(dAtA[i:])
			if err9 != nil {
			return 0, err9
			}
			i += n9
			}
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
			n10, err10 := m.PtMouth.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
			n10, err10 := m.PtRightEye.MarshalTo(dAtA[i:])
			if err10 != nil {
			return 0, err10
			}
			i += n10
			}
			if m.PtNose != nil {
			dAtA[i] = 0x2a
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.PtNose.Size()))
			n11, err11 := m.PtNose.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
			n11, err11 := m.PtMouth.MarshalTo(dAtA[i:])
			if err11 != nil {
			return 0, err11
			}
			i += n11
			}
			if m.FAngle != nil {
			dAtA[i] = 0x32
			if m.PtNose != nil {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FAngle.Size()))
			n12, err12 := m.FAngle.MarshalTo(dAtA[i:])
			i = encodeVarintSdk(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 = encodeVarintSdk(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
			@@ -1051,9 +2399,6 @@
			dAtA[i] = 0x48
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}
			@@ -1077,11 +2422,11 @@
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcObj.Size()))
			n13, err13 := m.RcObj.MarshalTo(dAtA[i:])
			if err13 != nil {
			return 0, err13
			n14, err14 := m.RcObj.MarshalTo(dAtA[i:])
			if err14 != nil {
			return 0, err14
			}
			i += n13
			i += n14
			}
			if m.Typ != 0 {
			dAtA[i] = 0x10
			@@ -1094,8 +2439,54 @@
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
			i += 4
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			if m.ObjID != 0 {
			dAtA[i] = 0x20
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.ObjID))
			}
			return i, nil
			}

			func (m *ResultFaceDetect) 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 *ResultFaceDetect) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.Pos != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
			n15, err15 := m.Pos.MarshalTo(dAtA[i:])
			if err15 != nil {
			return 0, err15
			}
			i += n15
			}
			if m.Result != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Result.Size()))
			n16, err16 := m.Result.MarshalTo(dAtA[i:])
			if err16 != nil {
			return 0, err16
			}
			i += n16
			}
			if len(m.Feats) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
			i += copy(dAtA[i:], m.Feats)
			}
			return i, nil
			}
			@@ -1115,43 +2506,22 @@
			_ = i
			var l int
			_ = l
			if m.Pos != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
			n14, err14 := m.Pos.MarshalTo(dAtA[i:])
			if err14 != nil {
			return 0, err14
			if len(m.Faces) > 0 {
			for _, msg := range m.Faces {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			i += n14
			}
			if m.Result != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Result.Size()))
			n15, err15 := m.Result.MarshalTo(dAtA[i:])
			if err15 != nil {
			return 0, err15
			}
			i += n15
			}
			if m.Img != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Img.Size()))
			n16, err16 := m.Img.MarshalTo(dAtA[i:])
			if err16 != nil {
			return 0, err16
			}
			i += n16
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *ParamFaceCompare) Marshal() (dAtA []byte, err error) {
			func (m *ResultFaceExtCom) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalTo(dAtA)
			@@ -1161,25 +2531,62 @@
			return dAtA[:n], nil
			}

			func (m *ParamFaceCompare) MarshalTo(dAtA []byte) (int, error) {
			func (m *ResultFaceExtCom) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Feat1) > 0 {
			if len(m.Feats) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feat1)))
			i += copy(dAtA[i:], m.Feat1)
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
			i += copy(dAtA[i:], m.Feats)
			}
			if len(m.Feat2) > 0 {
			if len(m.Comp) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feat2)))
			i += copy(dAtA[i:], m.Feat2)
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Comp)))
			i += copy(dAtA[i:], m.Comp)
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			if m.Pos != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
			n17, err17 := m.Pos.MarshalTo(dAtA[i:])
			if err17 != nil {
			return 0, err17
			}
			i += n17
			}
			return i, nil
			}

			func (m *ParamFaceFeature) 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 *ParamFaceFeature) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.ExtComp) > 0 {
			for _, msg := range m.ExtComp {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			return i, nil
			}
			@@ -1211,18 +2618,538 @@
			i += n
			}
			}
			if m.Img != nil {
			return i, nil
			}

			func (m *SoInfo) 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 *SoInfo) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Id) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Id)))
			i += copy(dAtA[i:], m.Id)
			}
			if len(m.SdkId) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Img.Size()))
			n17, err17 := m.Img.MarshalTo(dAtA[i:])
			if err17 != nil {
			return 0, err17
			}
			i += n17
			i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkId)))
			i += copy(dAtA[i:], m.SdkId)
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			if len(m.SoName) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.SoName)))
			i += copy(dAtA[i:], m.SoName)
			}
			return i, nil
			}

			func (m *PlateID) 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 *PlateID) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.License) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
			i += copy(dAtA[i:], m.License)
			}
			if len(m.Color) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Color)))
			i += copy(dAtA[i:], m.Color)
			}
			if m.NColor != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
			}
			if m.NType != 0 {
			dAtA[i] = 0x20
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NType))
			}
			if m.NConfidence != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
			}
			if m.NBright != 0 {
			dAtA[i] = 0x30
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NBright))
			}
			if m.NDirection != 0 {
			dAtA[i] = 0x38
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NDirection))
			}
			if m.RcLocation != nil {
			dAtA[i] = 0x42
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
			n18, err18 := m.RcLocation.MarshalTo(dAtA[i:])
			if err18 != nil {
			return 0, err18
			}
			i += n18
			}
			if m.NTime != 0 {
			dAtA[i] = 0x48
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NTime))
			}
			if m.NCarBright != 0 {
			dAtA[i] = 0x50
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
			}
			if m.NCarColor != 0 {
			dAtA[i] = 0x58
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor))
			}
			if m.NCarLogo != 0 {
			dAtA[i] = 0x60
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarLogo))
			}
			if m.NCarType != 0 {
			dAtA[i] = 0x68
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarType))
			}
			if len(m.PlateBin) > 0 {
			dAtA[i] = 0x72
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.PlateBin)))
			i += copy(dAtA[i:], m.PlateBin)
			}
			if len(m.NBinPlateWidth) > 0 {
			dAtA[i] = 0x7a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateWidth)))
			i += copy(dAtA[i:], m.NBinPlateWidth)
			}
			if len(m.NBinPlateHeight) > 0 {
			dAtA[i] = 0x82
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateHeight)))
			i += copy(dAtA[i:], m.NBinPlateHeight)
			}
			if m.RcLogoLocation != nil {
			dAtA[i] = 0x8a
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLogoLocation.Size()))
			n19, err19 := m.RcLogoLocation.MarshalTo(dAtA[i:])
			if err19 != nil {
			return 0, err19
			}
			i += n19
			}
			if len(m.NCarModel) > 0 {
			dAtA[i] = 0x92
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.NCarModel)))
			i += copy(dAtA[i:], m.NCarModel)
			}
			if len(m.NCarModelConfidence) > 0 {
			dAtA[i] = 0x9a
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.NCarModelConfidence)))
			i += copy(dAtA[i:], m.NCarModelConfidence)
			}
			return i, nil
			}

			func (m *PlateIDCloud) 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 *PlateIDCloud) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.License) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
			i += copy(dAtA[i:], m.License)
			}
			if m.RcLocation != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
			n20, err20 := m.RcLocation.MarshalTo(dAtA[i:])
			if err20 != nil {
			return 0, err20
			}
			i += n20
			}
			if m.NConfidence != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
			}
			if m.NType != 0 {
			dAtA[i] = 0x20
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NType))
			}
			if m.NDirection != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NDirection))
			}
			if m.NCarColor != 0 {
			dAtA[i] = 0x30
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor))
			}
			if m.NCarColor1 != 0 {
			dAtA[i] = 0x38
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor1))
			}
			if m.NCarBright != 0 {
			dAtA[i] = 0x40
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
			}
			if m.FrameNo != 0 {
			dAtA[i] = 0x48
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FrameNo))
			}
			if m.FaceWidth != 0 {
			dAtA[i] = 0x50
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FaceWidth))
			}
			if m.FaceHeight != 0 {
			dAtA[i] = 0x58
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.FaceHeight))
			}
			if m.GrayFaceFlag != 0 {
			dAtA[i] = 0x60
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.GrayFaceFlag))
			}
			if m.CharNum != 0 {
			dAtA[i] = 0x68
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.CharNum))
			}
			return i, nil
			}

			func (m *PlateIDVehicle) 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 *PlateIDVehicle) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.NPlateFlag != 0 {
			dAtA[i] = 0x8
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NPlateFlag))
			}
			if m.NColor != 0 {
			dAtA[i] = 0x10
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
			}
			if m.NType != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NType))
			}
			if len(m.License) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
			i += copy(dAtA[i:], m.License)
			}
			if m.NConfidence != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
			}
			if m.NCharNum != 0 {
			dAtA[i] = 0x30
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NCharNum))
			}
			if len(m.NCharConfidence) > 0 {
			dAtA22 := make([]byte, len(m.NCharConfidence)*10)
			var j21 int
			for _, num1 := range m.NCharConfidence {
			num := uint64(num1)
			for num >= 1<<7 {
			dAtA22[j21] = uint8(uint64(num)&0x7f \| 0x80)
			num >>= 7
			j21++
			}
			dAtA22[j21] = uint8(num)
			j21++
			}
			dAtA[i] = 0x3a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(j21))
			i += copy(dAtA[i:], dAtA22[:j21])
			}
			if m.RcLocation != nil {
			dAtA[i] = 0x42
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
			n23, err23 := m.RcLocation.MarshalTo(dAtA[i:])
			if err23 != nil {
			return 0, err23
			}
			i += n23
			}
			if m.RcCarLocation != nil {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcCarLocation.Size()))
			n24, err24 := m.RcCarLocation.MarshalTo(dAtA[i:])
			if err24 != nil {
			return 0, err24
			}
			i += n24
			}
			if len(m.VehicleType) > 0 {
			dAtA[i] = 0x52
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType)))
			i += copy(dAtA[i:], m.VehicleType)
			}
			if len(m.VehicleBrand) > 0 {
			dAtA[i] = 0x5a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleBrand)))
			i += copy(dAtA[i:], m.VehicleBrand)
			}
			if len(m.VehicleSub) > 0 {
			dAtA[i] = 0x62
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleSub)))
			i += copy(dAtA[i:], m.VehicleSub)
			}
			if len(m.VehicleType1) > 0 {
			dAtA[i] = 0x6a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType1)))
			i += copy(dAtA[i:], m.VehicleType1)
			}
			if m.FvdConf != 0 {
			dAtA[i] = 0x75
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FvdConf))))
			i += 4
			}
			if m.FConfdence != 0 {
			dAtA[i] = 0x7d
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FConfdence))))
			i += 4
			}
			if m.NVehicleSubModel != 0 {
			dAtA[i] = 0x80
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleSubModel))
			}
			if m.NVehicleBright != 0 {
			dAtA[i] = 0x88
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleBright))
			}
			if m.NVehicleColor1 != 0 {
			dAtA[i] = 0x90
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor1))
			}
			if m.NVehicleColor2 != 0 {
			dAtA[i] = 0x98
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor2))
			}
			return i, nil
			}

			func (m *PlateIDResult) 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 *PlateIDResult) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Result) > 0 {
			for _, msg := range m.Result {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			return i, nil
			}

			func (m *HumanTrack) 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 *HumanTrack) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.RcHuman != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcHuman.Size()))
			n25, err25 := m.RcHuman.MarshalTo(dAtA[i:])
			if err25 != nil {
			return 0, err25
			}
			i += n25
			}
			if m.Confidence != 0 {
			dAtA[i] = 0x15
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
			i += 4
			}
			if m.X != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.X))
			}
			if m.Y != 0 {
			dAtA[i] = 0x20
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Y))
			}
			if m.Id != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Id))
			}
			if len(m.Feature) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feature)*4))
			for _, num := range m.Feature {
			f26 := math.Float32bits(float32(num))
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f26))
			i += 4
			}
			}
			return i, nil
			}

			func (m *HumanTrackResult) 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 *HumanTrackResult) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Result) > 0 {
			for _, msg := range m.Result {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			return i, nil
			}
			@@ -1252,8 +3179,111 @@
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			l = len(m.Timestamp)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.Id != 0 {
			n += 1 + sovSdk(uint64(m.Id))
			}
			l = len(m.Cid)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.Cname)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.Channel != 0 {
			n += 1 + sovSdk(uint64(m.Channel))
			}
			if m.I64Timestamp != 0 {
			n += 1 + sovSdk(uint64(m.I64Timestamp))
			}
			return n
			}

			func (m *Target) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			if m.Id != 0 {
			n += 1 + sovSdk(uint64(m.Id))
			}
			l = len(m.Type)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.Confidence != 0 {
			n += 1 + sovSdk(uint64(m.Confidence))
			}
			if m.Rect != nil {
			l = m.Rect.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.Feature)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.Attribute)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			return n
			}

			func (m *NewSDKMessage) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.SdkID)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.SdkType)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.SdkName)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if len(m.Target) > 0 {
			for _, e := range m.Target {
			l = e.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			}
			l = len(m.Timestamp)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			return n
			}

			func (m *NewRuleMessage) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.DataType)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.HandleTrack)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if len(m.Message) > 0 {
			for _, e := range m.Message {
			l = e.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			}
			return n
			}
			@@ -1275,9 +3305,6 @@
			}
			if m.Confidence != 0 {
			n += 5
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}
			@@ -1302,9 +3329,6 @@
			}
			if m.Smile != 0 {
			n += 1 + sovSdk(uint64(m.Smile))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}
			@@ -1346,8 +3370,8 @@
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			if m.FaceID != 0 {
			n += 1 + sovSdk(uint64(m.FaceID))
			}
			return n
			}
			@@ -1392,9 +3416,6 @@
			if m.FaceID != 0 {
			n += 1 + sovSdk(uint64(m.FaceID))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}

			@@ -1414,13 +3435,13 @@
			if m.Prob != 0 {
			n += 5
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			if m.ObjID != 0 {
			n += 1 + sovSdk(uint64(m.ObjID))
			}
			return n
			}

			func (m *ParamFacePos) Size() (n int) {
			func (m *ResultFaceDetect) Size() (n int) {
			if m == nil {
			return 0
			}
			@@ -1434,32 +3455,60 @@
			l = m.Result.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.Img != nil {
			l = m.Img.Size()
			l = len(m.Feats)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}

			func (m *ParamFaceCompare) Size() (n int) {
			func (m *ParamFacePos) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Feat1)
			if len(m.Faces) > 0 {
			for _, e := range m.Faces {
			l = e.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			}
			return n
			}

			func (m *ResultFaceExtCom) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Feats)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.Feat2)
			l = len(m.Comp)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			if m.Pos != nil {
			l = m.Pos.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			return n
			}

			func (m *ParamFaceFeature) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			if len(m.ExtComp) > 0 {
			for _, e := range m.ExtComp {
			l = e.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			}
			return n
			}
			@@ -1476,12 +3525,286 @@
			n += 1 + l + sovSdk(uint64(l))
			}
			}
			if m.Img != nil {
			l = m.Img.Size()
			return n
			}

			func (m *SoInfo) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Id)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			l = len(m.SdkId)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.SoName)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			return n
			}

			func (m *PlateID) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.License)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.Color)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.NColor != 0 {
			n += 1 + sovSdk(uint64(m.NColor))
			}
			if m.NType != 0 {
			n += 1 + sovSdk(uint64(m.NType))
			}
			if m.NConfidence != 0 {
			n += 1 + sovSdk(uint64(m.NConfidence))
			}
			if m.NBright != 0 {
			n += 1 + sovSdk(uint64(m.NBright))
			}
			if m.NDirection != 0 {
			n += 1 + sovSdk(uint64(m.NDirection))
			}
			if m.RcLocation != nil {
			l = m.RcLocation.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.NTime != 0 {
			n += 1 + sovSdk(uint64(m.NTime))
			}
			if m.NCarBright != 0 {
			n += 1 + sovSdk(uint64(m.NCarBright))
			}
			if m.NCarColor != 0 {
			n += 1 + sovSdk(uint64(m.NCarColor))
			}
			if m.NCarLogo != 0 {
			n += 1 + sovSdk(uint64(m.NCarLogo))
			}
			if m.NCarType != 0 {
			n += 1 + sovSdk(uint64(m.NCarType))
			}
			l = len(m.PlateBin)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.NBinPlateWidth)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.NBinPlateHeight)
			if l > 0 {
			n += 2 + l + sovSdk(uint64(l))
			}
			if m.RcLogoLocation != nil {
			l = m.RcLogoLocation.Size()
			n += 2 + l + sovSdk(uint64(l))
			}
			l = len(m.NCarModel)
			if l > 0 {
			n += 2 + l + sovSdk(uint64(l))
			}
			l = len(m.NCarModelConfidence)
			if l > 0 {
			n += 2 + l + sovSdk(uint64(l))
			}
			return n
			}

			func (m *PlateIDCloud) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.License)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.RcLocation != nil {
			l = m.RcLocation.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.NConfidence != 0 {
			n += 1 + sovSdk(uint64(m.NConfidence))
			}
			if m.NType != 0 {
			n += 1 + sovSdk(uint64(m.NType))
			}
			if m.NDirection != 0 {
			n += 1 + sovSdk(uint64(m.NDirection))
			}
			if m.NCarColor != 0 {
			n += 1 + sovSdk(uint64(m.NCarColor))
			}
			if m.NCarColor1 != 0 {
			n += 1 + sovSdk(uint64(m.NCarColor1))
			}
			if m.NCarBright != 0 {
			n += 1 + sovSdk(uint64(m.NCarBright))
			}
			if m.FrameNo != 0 {
			n += 1 + sovSdk(uint64(m.FrameNo))
			}
			if m.FaceWidth != 0 {
			n += 1 + sovSdk(uint64(m.FaceWidth))
			}
			if m.FaceHeight != 0 {
			n += 1 + sovSdk(uint64(m.FaceHeight))
			}
			if m.GrayFaceFlag != 0 {
			n += 1 + sovSdk(uint64(m.GrayFaceFlag))
			}
			if m.CharNum != 0 {
			n += 1 + sovSdk(uint64(m.CharNum))
			}
			return n
			}

			func (m *PlateIDVehicle) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			if m.NPlateFlag != 0 {
			n += 1 + sovSdk(uint64(m.NPlateFlag))
			}
			if m.NColor != 0 {
			n += 1 + sovSdk(uint64(m.NColor))
			}
			if m.NType != 0 {
			n += 1 + sovSdk(uint64(m.NType))
			}
			l = len(m.License)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.NConfidence != 0 {
			n += 1 + sovSdk(uint64(m.NConfidence))
			}
			if m.NCharNum != 0 {
			n += 1 + sovSdk(uint64(m.NCharNum))
			}
			if len(m.NCharConfidence) > 0 {
			l = 0
			for _, e := range m.NCharConfidence {
			l += sovSdk(uint64(e))
			}
			n += 1 + sovSdk(uint64(l)) + l
			}
			if m.RcLocation != nil {
			l = m.RcLocation.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.RcCarLocation != nil {
			l = m.RcCarLocation.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.VehicleType)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.VehicleBrand)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.VehicleSub)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			l = len(m.VehicleType1)
			if l > 0 {
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.FvdConf != 0 {
			n += 5
			}
			if m.FConfdence != 0 {
			n += 5
			}
			if m.NVehicleSubModel != 0 {
			n += 2 + sovSdk(uint64(m.NVehicleSubModel))
			}
			if m.NVehicleBright != 0 {
			n += 2 + sovSdk(uint64(m.NVehicleBright))
			}
			if m.NVehicleColor1 != 0 {
			n += 2 + sovSdk(uint64(m.NVehicleColor1))
			}
			if m.NVehicleColor2 != 0 {
			n += 2 + sovSdk(uint64(m.NVehicleColor2))
			}
			return n
			}

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

			func (m *HumanTrack) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			if m.RcHuman != nil {
			l = m.RcHuman.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.Confidence != 0 {
			n += 5
			}
			if m.X != 0 {
			n += 1 + sovSdk(uint64(m.X))
			}
			if m.Y != 0 {
			n += 1 + sovSdk(uint64(m.Y))
			}
			if m.Id != 0 {
			n += 1 + sovSdk(uint64(m.Id))
			}
			if len(m.Feature) > 0 {
			n += 1 + sovSdk(uint64(len(m.Feature)4)) + len(m.Feature)4
			}
			return n
			}

			func (m *HumanTrackResult) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			if len(m.Result) > 0 {
			for _, e := range m.Result {
			l = e.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			}
			return n
			}
			@@ -1600,6 +3923,159 @@
			m.Data = []byte{}
			}
			iNdEx = postIndex
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Timestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Id \|= int64(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			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 ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 7:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Cname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Cname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 8:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Channel", wireType)
			}
			m.Channel = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Channel \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 9:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field I64Timestamp", wireType)
			}
			m.I64Timestamp = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.I64Timestamp \|= int64(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			@@ -1615,7 +4091,599 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *Target) 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 ErrIntOverflowSdk
			}
			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: Target: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: Target: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Id \|= uint64(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Confidence", wireType)
			}
			m.Confidence = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Confidence \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Rect", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.Rect == nil {
			m.Rect = &Rect{}
			}
			if err := m.Rect.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Feature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Feature = append(m.Feature[:0], dAtA[iNdEx:postIndex]...)
			if m.Feature == nil {
			m.Feature = []byte{}
			}
			iNdEx = postIndex
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Attribute", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Attribute = append(m.Attribute[:0], dAtA[iNdEx:postIndex]...)
			if m.Attribute == nil {
			m.Attribute = []byte{}
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *NewSDKMessage) 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 ErrIntOverflowSdk
			}
			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: NewSDKMessage: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: NewSDKMessage: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Target = append(m.Target, &Target{})
			if err := m.Target[len(m.Target)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Timestamp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *NewRuleMessage) 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 ErrIntOverflowSdk
			}
			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: NewRuleMessage: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: NewRuleMessage: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			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 ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.DataType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field HandleTrack", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.HandleTrack = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Message = append(m.Message, &NewSDKMessage{})
			if err := m.Message[len(m.Message)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}
			@@ -1737,7 +4805,6 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}
			@@ -1886,7 +4953,6 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}
			@@ -2194,6 +5260,25 @@
			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 ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.FaceID \|= uint64(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			@@ -2209,7 +5294,6 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}
			@@ -2551,7 +5635,6 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}
			@@ -2656,6 +5739,25 @@
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Prob = float32(math.Float32frombits(v))
			case 4:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field ObjID", wireType)
			}
			m.ObjID = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.ObjID \|= uint64(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			@@ -2671,7 +5773,6 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}
			@@ -2681,7 +5782,7 @@
			}
			return nil
			}
			func (m *ParamFacePos) Unmarshal(dAtA []byte) error {
			func (m *ResultFaceDetect) Unmarshal(dAtA []byte) error {
			l := len(dAtA)
			iNdEx := 0
			for iNdEx < l {
			@@ -2704,10 +5805,10 @@
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
			return fmt.Errorf("proto: ParamFacePos: wiretype end group for non-group")
			return fmt.Errorf("proto: ResultFaceDetect: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamFacePos: illegal tag %d (wire type %d)", fieldNum, wire)
			return fmt.Errorf("proto: ResultFaceDetect: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			@@ -2784,7 +5885,94 @@
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Img", wireType)
			return fmt.Errorf("proto: wrong wireType = %d for field Feats", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Feats = append(m.Feats[:0], dAtA[iNdEx:postIndex]...)
			if m.Feats == nil {
			m.Feats = []byte{}
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *ParamFacePos) 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 ErrIntOverflowSdk
			}
			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: ParamFacePos: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamFacePos: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Faces", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			@@ -2811,10 +5999,8 @@
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.Img == nil {
			m.Img = &Image{}
			}
			if err := m.Img.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			m.Faces = append(m.Faces, &ResultFaceDetect{})
			if err := m.Faces[len(m.Faces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			@@ -2833,7 +6019,6 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}
			@@ -2843,7 +6028,7 @@
			}
			return nil
			}
			func (m *ParamFaceCompare) Unmarshal(dAtA []byte) error {
			func (m *ResultFaceExtCom) Unmarshal(dAtA []byte) error {
			l := len(dAtA)
			iNdEx := 0
			for iNdEx < l {
			@@ -2866,15 +6051,15 @@
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
			return fmt.Errorf("proto: ParamFaceCompare: wiretype end group for non-group")
			return fmt.Errorf("proto: ResultFaceExtCom: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamFaceCompare: illegal tag %d (wire type %d)", fieldNum, wire)
			return fmt.Errorf("proto: ResultFaceExtCom: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Feat1", wireType)
			return fmt.Errorf("proto: wrong wireType = %d for field Feats", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			@@ -2901,14 +6086,14 @@
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Feat1 = append(m.Feat1[:0], dAtA[iNdEx:postIndex]...)
			if m.Feat1 == nil {
			m.Feat1 = []byte{}
			m.Feats = append(m.Feats[:0], dAtA[iNdEx:postIndex]...)
			if m.Feats == nil {
			m.Feats = []byte{}
			}
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Feat2", wireType)
			return fmt.Errorf("proto: wrong wireType = %d for field Comp", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			@@ -2935,9 +6120,45 @@
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Feat2 = append(m.Feat2[:0], dAtA[iNdEx:postIndex]...)
			if m.Feat2 == nil {
			m.Feat2 = []byte{}
			m.Comp = append(m.Comp[:0], dAtA[iNdEx:postIndex]...)
			if m.Comp == nil {
			m.Comp = []byte{}
			}
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
			m.Pos = &ResultFaceDetect{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			default:
			@@ -2955,7 +6176,93 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}

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

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *SoInfo) 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 ErrIntOverflowSdk
			}
			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: SoInfo: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: SoInfo: 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 ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			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 Img", wireType)
			return fmt.Errorf("proto: wrong wireType = %d for field SdkId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SoName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SoName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *PlateID) 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 ErrIntOverflowSdk
			}
			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: PlateID: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: PlateID: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.License = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NColor", wireType)
			}
			m.NColor = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NColor \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NType", wireType)
			}
			m.NType = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NType \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NConfidence", wireType)
			}
			m.NConfidence = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NConfidence \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NBright", wireType)
			}
			m.NBright = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NBright \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 7:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NDirection", wireType)
			}
			m.NDirection = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NDirection \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 8:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcLocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			@@ -3057,10 +6725,1282 @@
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.Img == nil {
			m.Img = &Image{}
			if m.RcLocation == nil {
			m.RcLocation = &Rect{}
			}
			if err := m.Img.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			if err := m.RcLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 9:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NTime", wireType)
			}
			m.NTime = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NTime \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 10:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarBright", wireType)
			}
			m.NCarBright = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarBright \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 11:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarColor", wireType)
			}
			m.NCarColor = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarColor \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 12:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarLogo", wireType)
			}
			m.NCarLogo = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarLogo \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 13:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarType", wireType)
			}
			m.NCarType = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarType \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 14:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field PlateBin", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.PlateBin = append(m.PlateBin[:0], dAtA[iNdEx:postIndex]...)
			if m.PlateBin == nil {
			m.PlateBin = []byte{}
			}
			iNdEx = postIndex
			case 15:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field NBinPlateWidth", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.NBinPlateWidth = append(m.NBinPlateWidth[:0], dAtA[iNdEx:postIndex]...)
			if m.NBinPlateWidth == nil {
			m.NBinPlateWidth = []byte{}
			}
			iNdEx = postIndex
			case 16:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field NBinPlateHeight", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.NBinPlateHeight = append(m.NBinPlateHeight[:0], dAtA[iNdEx:postIndex]...)
			if m.NBinPlateHeight == nil {
			m.NBinPlateHeight = []byte{}
			}
			iNdEx = postIndex
			case 17:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcLogoLocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.RcLogoLocation == nil {
			m.RcLogoLocation = &Rect{}
			}
			if err := m.RcLogoLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 18:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarModel", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.NCarModel = append(m.NCarModel[:0], dAtA[iNdEx:postIndex]...)
			if m.NCarModel == nil {
			m.NCarModel = []byte{}
			}
			iNdEx = postIndex
			case 19:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarModelConfidence", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			byteLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if byteLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.NCarModelConfidence = append(m.NCarModelConfidence[:0], dAtA[iNdEx:postIndex]...)
			if m.NCarModelConfidence == nil {
			m.NCarModelConfidence = []byte{}
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *PlateIDCloud) 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 ErrIntOverflowSdk
			}
			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: PlateIDCloud: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: PlateIDCloud: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.License = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcLocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.RcLocation == nil {
			m.RcLocation = &Rect{}
			}
			if err := m.RcLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 3:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NConfidence", wireType)
			}
			m.NConfidence = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NConfidence \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NType", wireType)
			}
			m.NType = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NType \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NDirection", wireType)
			}
			m.NDirection = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NDirection \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarColor", wireType)
			}
			m.NCarColor = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarColor \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 7:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarColor1", wireType)
			}
			m.NCarColor1 = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarColor1 \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 8:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCarBright", wireType)
			}
			m.NCarBright = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCarBright \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 9:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field FrameNo", wireType)
			}
			m.FrameNo = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.FrameNo \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 10:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field FaceWidth", wireType)
			}
			m.FaceWidth = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.FaceWidth \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 11:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field FaceHeight", wireType)
			}
			m.FaceHeight = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.FaceHeight \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 12:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field GrayFaceFlag", wireType)
			}
			m.GrayFaceFlag = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.GrayFaceFlag \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 13:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field CharNum", wireType)
			}
			m.CharNum = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.CharNum \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *PlateIDVehicle) 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 ErrIntOverflowSdk
			}
			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: PlateIDVehicle: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: PlateIDVehicle: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NPlateFlag", wireType)
			}
			m.NPlateFlag = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NPlateFlag \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 2:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NColor", wireType)
			}
			m.NColor = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NColor \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 3:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NType", wireType)
			}
			m.NType = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NType \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.License = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NConfidence", wireType)
			}
			m.NConfidence = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NConfidence \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NCharNum", wireType)
			}
			m.NCharNum = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NCharNum \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 7:
			if wireType == 0 {
			var v int32
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.NCharConfidence = append(m.NCharConfidence, v)
			} else if wireType == 2 {
			var packedLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			packedLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if packedLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + packedLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			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.NCharConfidence) == 0 {
			m.NCharConfidence = make([]int32, 0, elementCount)
			}
			for iNdEx < postIndex {
			var v int32
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.NCharConfidence = append(m.NCharConfidence, v)
			}
			} else {
			return fmt.Errorf("proto: wrong wireType = %d for field NCharConfidence", wireType)
			}
			case 8:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcLocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.RcLocation == nil {
			m.RcLocation = &Rect{}
			}
			if err := m.RcLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 9:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcCarLocation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.RcCarLocation == nil {
			m.RcCarLocation = &Rect{}
			}
			if err := m.RcCarLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 10:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field VehicleType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.VehicleType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 11:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field VehicleBrand", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.VehicleBrand = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 12:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field VehicleSub", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.VehicleSub = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 13:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field VehicleType1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			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 ErrInvalidLengthSdk
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.VehicleType1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 14:
			if wireType != 5 {
			return fmt.Errorf("proto: wrong wireType = %d for field FvdConf", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
			return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.FvdConf = float32(math.Float32frombits(v))
			case 15:
			if wireType != 5 {
			return fmt.Errorf("proto: wrong wireType = %d for field FConfdence", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
			return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.FConfdence = float32(math.Float32frombits(v))
			case 16:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NVehicleSubModel", wireType)
			}
			m.NVehicleSubModel = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NVehicleSubModel \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 17:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NVehicleBright", wireType)
			}
			m.NVehicleBright = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NVehicleBright \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 18:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NVehicleColor1", wireType)
			}
			m.NVehicleColor1 = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NVehicleColor1 \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 19:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field NVehicleColor2", wireType)
			}
			m.NVehicleColor2 = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.NVehicleColor2 \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *PlateIDResult) 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 ErrIntOverflowSdk
			}
			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: PlateIDResult: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: PlateIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Result = append(m.Result, &PlateIDVehicle{})
			if err := m.Result[len(m.Result)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			@@ -3079,7 +8019,304 @@
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *HumanTrack) 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 ErrIntOverflowSdk
			}
			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: HumanTrack: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: HumanTrack: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcHuman", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.RcHuman == nil {
			m.RcHuman = &Rect{}
			}
			if err := m.RcHuman.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 2:
			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))
			case 3:
			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 ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.X \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			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 ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Y \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Id \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			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.Feature = append(m.Feature, v2)
			} else if wireType == 2 {
			var packedLen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			packedLen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if packedLen < 0 {
			return ErrInvalidLengthSdk
			}
			postIndex := iNdEx + packedLen
			if postIndex < 0 {
			return ErrInvalidLengthSdk
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			var elementCount int
			elementCount = packedLen / 4
			if elementCount != 0 && len(m.Feature) == 0 {
			m.Feature = 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.Feature = append(m.Feature, v2)
			}
			} else {
			return fmt.Errorf("proto: wrong wireType = %d for field Feature", wireType)
			}
			default:
			iNdEx = preIndex
			skippy, err := skipSdk(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthSdk
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

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