pubsub/protomsg.git

			@@ -24,12 +24,15 @@

			// 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"`
			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"`
			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{} }
			@@ -107,6 +110,247 @@
			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"`
			@@ -118,7 +362,7 @@
			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)
			@@ -187,7 +431,7 @@
			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)
			@@ -267,7 +511,7 @@
			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)
			@@ -375,7 +619,7 @@
			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)
			@@ -478,7 +722,7 @@
			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)
			@@ -546,7 +790,7 @@
			func (m *ResultFaceDetect) String() string { return proto.CompactTextString(m) }
			func (*ResultFaceDetect) ProtoMessage() {}
			func (*ResultFaceDetect) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{6}
			return fileDescriptor_70decb0fb6f436df, []int{9}
			}
			func (m *ResultFaceDetect) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -604,7 +848,7 @@
			func (m *ParamFacePos) String() string { return proto.CompactTextString(m) }
			func (*ParamFacePos) ProtoMessage() {}
			func (*ParamFacePos) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{7}
			return fileDescriptor_70decb0fb6f436df, []int{10}
			}
			func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -650,7 +894,7 @@
			func (m *ResultFaceExtCom) String() string { return proto.CompactTextString(m) }
			func (*ResultFaceExtCom) ProtoMessage() {}
			func (*ResultFaceExtCom) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{8}
			return fileDescriptor_70decb0fb6f436df, []int{11}
			}
			func (m *ResultFaceExtCom) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -708,7 +952,7 @@
			func (m *ParamFaceFeature) String() string { return proto.CompactTextString(m) }
			func (*ParamFaceFeature) ProtoMessage() {}
			func (*ParamFaceFeature) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{9}
			return fileDescriptor_70decb0fb6f436df, []int{12}
			}
			func (m *ParamFaceFeature) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -753,7 +997,7 @@
			func (m *ParamYoloObj) String() string { return proto.CompactTextString(m) }
			func (*ParamYoloObj) ProtoMessage() {}
			func (*ParamYoloObj) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{10}
			return fileDescriptor_70decb0fb6f436df, []int{13}
			}
			func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -799,7 +1043,7 @@
			func (m *SoInfo) String() string { return proto.CompactTextString(m) }
			func (*SoInfo) ProtoMessage() {}
			func (*SoInfo) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{11}
			return fileDescriptor_70decb0fb6f436df, []int{14}
			}
			func (m *SoInfo) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -876,7 +1120,7 @@
			func (m *PlateID) String() string { return proto.CompactTextString(m) }
			func (*PlateID) ProtoMessage() {}
			func (*PlateID) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{12}
			return fileDescriptor_70decb0fb6f436df, []int{15}
			}
			func (m *PlateID) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -1059,7 +1303,7 @@
			func (m *PlateIDCloud) String() string { return proto.CompactTextString(m) }
			func (*PlateIDCloud) ProtoMessage() {}
			func (*PlateIDCloud) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{13}
			return fileDescriptor_70decb0fb6f436df, []int{16}
			}
			func (m *PlateIDCloud) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -1205,7 +1449,7 @@
			func (m *PlateIDVehicle) String() string { return proto.CompactTextString(m) }
			func (*PlateIDVehicle) ProtoMessage() {}
			func (*PlateIDVehicle) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{14}
			return fileDescriptor_70decb0fb6f436df, []int{17}
			}
			func (m *PlateIDVehicle) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -1377,7 +1621,7 @@
			func (m *PlateIDResult) String() string { return proto.CompactTextString(m) }
			func (*PlateIDResult) ProtoMessage() {}
			func (*PlateIDResult) Descriptor() ([]byte, []int) {
			return fileDescriptor_70decb0fb6f436df, []int{15}
			return fileDescriptor_70decb0fb6f436df, []int{18}
			}
			func (m *PlateIDResult) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -1414,22 +1658,19 @@
			}

			type HumanTrack struct {
			Left int32 `protobuf:"varint,1,opt,name=left,proto3" json:"left,omitempty"`
			Right int32 `protobuf:"varint,2,opt,name=right,proto3" json:"right,omitempty"`
			Top int32 `protobuf:"varint,3,opt,name=top,proto3" json:"top,omitempty"`
			Bottom int32 `protobuf:"varint,4,opt,name=bottom,proto3" json:"bottom,omitempty"`
			Confidence float32 `protobuf:"fixed32,5,opt,name=confidence,proto3" json:"confidence,omitempty"`
			X int32 `protobuf:"varint,6,opt,name=x,proto3" json:"x,omitempty"`
			Y int32 `protobuf:"varint,7,opt,name=y,proto3" json:"y,omitempty"`
			Id int32 `protobuf:"varint,8,opt,name=id,proto3" json:"id,omitempty"`
			Feature []float32 `protobuf:"fixed32,9,rep,packed,name=feature,proto3" json:"feature,omitempty"`
			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{16}
			return fileDescriptor_70decb0fb6f436df, []int{19}
			}
			func (m *HumanTrack) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -1458,32 +1699,11 @@

			var xxx_messageInfo_HumanTrack proto.InternalMessageInfo

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

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

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

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

			func (m *HumanTrack) GetConfidence() float32 {
			@@ -1523,14 +1743,13 @@

			type HumanTrackResult struct {
			Result []*HumanTrack `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
			Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,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{17}
			return fileDescriptor_70decb0fb6f436df, []int{20}
			}
			func (m *HumanTrackResult) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -1566,59 +1785,11 @@
			return nil
			}

			func (m *HumanTrackResult) GetCount() int32 {
			if m != nil {
			return m.Count
			}
			return 0
			}

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

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

			var xxx_messageInfo_HumanTrackResultLast proto.InternalMessageInfo

			func (m HumanTrackResultLast) GetResult() []HumanTrackResult {
			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")
			@@ -1636,103 +1807,111 @@
			proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
			proto.RegisterType((*HumanTrack)(nil), "protomsg.HumanTrack")
			proto.RegisterType((*HumanTrackResult)(nil), "protomsg.HumanTrackResult")
			proto.RegisterType((*HumanTrackResultLast)(nil), "protomsg.HumanTrackResultLast")
			}

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

			var fileDescriptor_70decb0fb6f436df = []byte{
			// 1429 bytes of a gzipped FileDescriptorProto
			0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x57, 0x4f, 0x6f, 0xdb, 0xc6,
			0x12, 0x0f, 0x25, 0x4b, 0xb2, 0xc6, 0x8e, 0xed, 0x6c, 0x82, 0x07, 0xc2, 0x78, 0x30, 0x04, 0xbe,
			0x87, 0x44, 0xef, 0x35, 0x75, 0x13, 0x37, 0x68, 0xaf, 0x8d, 0xed, 0x04, 0x71, 0xe1, 0x38, 0xc6,
			0x26, 0x70, 0xd1, 0xe3, 0x8a, 0x5c, 0x49, 0xb4, 0x49, 0x2e, 0x4b, 0xae, 0x12, 0x0b, 0xfd, 0x04,
			0xbd, 0xf5, 0x43, 0xf4, 0xdc, 0x8f, 0x51, 0xf4, 0x98, 0x63, 0x8f, 0x45, 0xd2, 0x7e, 0x84, 0xde,
			0x8b, 0x99, 0x5d, 0xfe, 0x11, 0xad, 0x24, 0x28, 0xd0, 0x63, 0x4f, 0xda, 0xdf, 0xec, 0x68, 0xe7,
			0xdf, 0x6f, 0x66, 0x97, 0xd0, 0xcf, 0x83, 0x8b, 0xdd, 0x34, 0x53, 0x5a, 0xb1, 0x55, 0xfa, 0x89,
			0xf3, 0xc9, 0x36, 0x8c, 0x44, 0x2e, 0x8d, 0xd4, 0xfb, 0xce, 0x81, 0xce, 0x51, 0x2c, 0x26, 0x92,
			0xdd, 0x82, 0xce, 0xab, 0x30, 0xd0, 0x53, 0xd7, 0x19, 0x38, 0xc3, 0x0e, 0x37, 0x80, 0xfd, 0x0b,
			0xba, 0x53, 0x19, 0x4e, 0xa6, 0xda, 0x6d, 0x91, 0xd8, 0x22, 0xc6, 0x60, 0x25, 0x10, 0x5a, 0xb8,
			0xed, 0x81, 0x33, 0x5c, 0xe7, 0xb4, 0x66, 0xff, 0x86, 0xbe, 0x0e, 0x63, 0x99, 0x6b, 0x11, 0xa7,
			0xee, 0xca, 0xc0, 0x19, 0xf6, 0x79, 0x25, 0x60, 0x1b, 0xd0, 0x0a, 0x03, 0xb7, 0x33, 0x70, 0x86,
			0x6d, 0xde, 0x0a, 0x03, 0xb6, 0x05, 0x6d, 0x3f, 0x0c, 0xdc, 0x2e, 0xe9, 0xe1, 0xd2, 0x9b, 0x40,
			0xff, 0xb1, 0xf0, 0xe5, 0xc3, 0x64, 0x12, 0x49, 0xdc, 0x9e, 0x8b, 0x57, 0xd6, 0x19, 0x5c, 0xa2,
			0x83, 0x69, 0xa8, 0xfd, 0xa9, 0xf5, 0xc4, 0x00, 0x74, 0x24, 0x53, 0x51, 0x44, 0x8e, 0x74, 0x38,
			0xad, 0xd9, 0x0e, 0x80, 0xaf, 0x92, 0x71, 0x18, 0xc8, 0xc4, 0x97, 0xe4, 0x49, 0x8b, 0xd7, 0x24,
			0xde, 0x25, 0xc0, 0x8b, 0xe9, 0x58, 0x73, 0x99, 0xcf, 0x22, 0x8d, 0x21, 0x4e, 0x64, 0x12, 0xc8,
			0xcc, 0x1a, 0xb3, 0x08, 0x3d, 0x10, 0x13, 0x69, 0xad, 0xe1, 0x92, 0x6c, 0x09, 0x5f, 0x96, 0xb6,
			0x84, 0x2f, 0xf1, 0xdf, 0x23, 0x29, 0x66, 0x7a, 0x4e, 0x76, 0x3a, 0xdc, 0x22, 0xf4, 0x36, 0x8f,
			0xc3, 0x48, 0x52, 0xc4, 0x1d, 0x6e, 0x80, 0xf7, 0x5b, 0x0b, 0x7a, 0x18, 0xe3, 0xa9, 0xca, 0xd9,
			0x6d, 0xe8, 0x66, 0x3e, 0x02, 0xb2, 0xbb, 0xb6, 0xb7, 0xb1, 0x5b, 0x54, 0x68, 0x97, 0x4b, 0x5f,
			0x73, 0xbb, 0xcb, 0x3e, 0x86, 0x7e, 0xaa, 0x8f, 0xe5, 0x58, 0x3f, 0x9a, 0x1b, 0x6f, 0xd6, 0xf6,
			0x36, 0x2b, 0xd5, 0x53, 0x15, 0x26, 0x9a, 0x57, 0x1a, 0xec, 0x13, 0x80, 0x54, 0x73, 0x2c, 0x12,
			0xea, 0xb7, 0x97, 0xeb, 0xd7, 0x54, 0xd8, 0xff, 0xa0, 0x97, 0xea, 0xa7, 0x6a, 0xa6, 0xa7, 0x14,
			0xc2, 0x12, 0xed, 0x62, 0x9f, 0xdd, 0x81, 0x6e, 0xaa, 0x4f, 0x54, 0x6e, 0xa2, 0x5a, 0xa2, 0x69,
			0xb7, 0xd9, 0x47, 0xd0, 0x1d, 0x53, 0x1d, 0xa9, 0xbe, 0x6b, 0x7b, 0x37, 0x2b, 0xc5, 0xb2, 0xc4,
			0xdc, 0xaa, 0x30, 0x17, 0x7a, 0xdf, 0xcc, 0x44, 0x14, 0xea, 0xb9, 0xdb, 0xa3, 0x64, 0x15, 0x10,
			0x0b, 0x39, 0x16, 0x7e, 0x28, 0xa2, 0x43, 0xe4, 0xda, 0x2a, 0x71, 0xad, 0x26, 0xc1, 0xe4, 0x8f,
			0x85, 0x2f, 0x8f, 0x0e, 0xdd, 0xfe, 0xc0, 0x19, 0xae, 0x70, 0x8b, 0xbc, 0xdf, 0x5b, 0xb0, 0x8a,
			0x76, 0x8e, 0x92, 0xb1, 0xfa, 0x27, 0xcf, 0x7f, 0x77, 0x9e, 0xdb, 0x65, 0x9e, 0x2f, 0xa0, 0xf7,
			0x6c, 0x74, 0x4e, 0x59, 0xfe, 0x2f, 0x74, 0x32, 0xff, 0xd9, 0xe8, 0xfc, 0x1d, 0x49, 0x36, 0x9b,
			0xd8, 0x53, 0x7a, 0x9e, 0x16, 0x3d, 0xa5, 0xe7, 0x29, 0xf6, 0x54, 0x9a, 0xa9, 0x11, 0x25, 0xb0,
			0xc5, 0x69, 0x8d, 0xbd, 0xa3, 0x46, 0xe7, 0x47, 0x87, 0x94, 0xa7, 0x15, 0x6e, 0x80, 0xf7, 0x2d,
			0x6c, 0x99, 0x8e, 0xc5, 0xc8, 0x0e, 0xa5, 0x96, 0xbe, 0x66, 0xff, 0x81, 0x76, 0xaa, 0x72, 0x6b,
			0xf3, 0xc6, 0x62, 0xf0, 0xa7, 0x2a, 0xe7, 0xb8, 0xcb, 0xee, 0x42, 0x37, 0xa3, 0x3f, 0xda, 0xaa,
			0xde, 0xaa, 0xf4, 0xaa, 0x31, 0xc0, 0xad, 0x0e, 0x1a, 0x1f, 0x4b, 0xa1, 0x73, 0x3b, 0xda, 0x0c,
			0xf0, 0xbe, 0x80, 0xf5, 0x53, 0x91, 0x89, 0xb8, 0x68, 0xde, 0x7b, 0xd0, 0xc1, 0x1c, 0xa0, 0xe9,
			0xf6, 0x70, 0x6d, 0x6f, 0xbb, 0x1e, 0xee, 0xa2, 0x8f, 0xdc, 0x28, 0x7a, 0xe7, 0x75, 0xf7, 0x1f,
			0x5d, 0xea, 0x03, 0x15, 0x57, 0xb6, 0x9c, 0x9a, 0x2d, 0x4c, 0x89, 0xaf, 0x62, 0x93, 0xa5, 0x75,
			0x4e, 0x6b, 0x76, 0xd7, 0x04, 0x6a, 0x68, 0xf6, 0x3e, 0x6b, 0xa8, 0xe6, 0x3d, 0x81, 0xad, 0xd2,
			0xdb, 0xc7, 0x52, 0xe8, 0x59, 0x26, 0xd9, 0x03, 0xe8, 0x49, 0xb2, 0x8a, 0x07, 0xbf, 0xd3, 0x67,
			0xe3, 0x18, 0x2f, 0x54, 0xbd, 0xcf, 0x6d, 0xdc, 0x5f, 0xab, 0x48, 0x61, 0x01, 0xef, 0x40, 0x27,
			0x4c, 0xc6, 0xaa, 0x88, 0xbb, 0x96, 0x72, 0x4b, 0x04, 0x6e, 0xf6, 0xbd, 0xc7, 0xd0, 0x7d, 0xae,
			0x88, 0x19, 0x66, 0xf0, 0x3b, 0x34, 0xe7, 0x71, 0xf0, 0xe3, 0x64, 0x0c, 0x2e, 0x8e, 0x02, 0x8a,
			0xaf, 0xcf, 0x0d, 0x40, 0x8a, 0xe5, 0xea, 0x44, 0xc4, 0xa6, 0x95, 0xfa, 0xdc, 0x22, 0xef, 0x8f,
			0x15, 0xe8, 0x9d, 0x46, 0x42, 0xcb, 0xa3, 0x43, 0x24, 0x70, 0x14, 0xfa, 0x32, 0xc9, 0xa5, 0x3d,
			0xae, 0x80, 0x78, 0xa6, 0xaf, 0x22, 0x95, 0x15, 0x67, 0x12, 0xc0, 0x33, 0x93, 0x03, 0x12, 0x9b,
			0x89, 0x6d, 0x11, 0x6a, 0x27, 0x2f, 0xe6, 0xa9, 0xb4, 0x23, 0xdb, 0x00, 0x36, 0x80, 0xb5, 0xe4,
			0xa0, 0xba, 0x36, 0xcc, 0xdc, 0xae, 0x8b, 0xd0, 0x7e, 0xb2, 0x9f, 0xd1, 0x6d, 0xd8, 0x35, 0x0d,
			0x64, 0x21, 0x36, 0x50, 0x72, 0x18, 0x66, 0xd2, 0xd7, 0xa1, 0x4a, 0x6c, 0x77, 0xd5, 0x24, 0x6c,
			0x17, 0x20, 0xf3, 0x8f, 0x95, 0x2f, 0x68, 0x7f, 0x75, 0x69, 0x8b, 0xd4, 0x34, 0x8c, 0x87, 0x61,
			0x2c, 0xa9, 0xdf, 0xc8, 0xc3, 0x30, 0x96, 0x64, 0xe5, 0x40, 0x64, 0xd6, 0x05, 0xb0, 0x56, 0x4a,
			0x09, 0x5e, 0xc0, 0x27, 0x07, 0x22, 0x33, 0x21, 0xaf, 0xd1, 0x76, 0x25, 0x60, 0xdb, 0xb0, 0x8a,
			0xba, 0xc7, 0x6a, 0xa2, 0xdc, 0x75, 0xda, 0x2c, 0x71, 0xb1, 0x47, 0x49, 0xb9, 0x5e, 0xed, 0x51,
			0x5e, 0xb6, 0x61, 0x35, 0xc5, 0x02, 0xec, 0x87, 0x89, 0xbb, 0x41, 0x94, 0x2c, 0x31, 0xbb, 0x0d,
			0x1b, 0xc9, 0x7e, 0x98, 0x50, 0x81, 0xbe, 0xa2, 0xd7, 0xc3, 0x26, 0x69, 0x34, 0xa4, 0x6c, 0x08,
			0x9b, 0xa5, 0xe4, 0x89, 0x79, 0x4f, 0x6c, 0x91, 0x62, 0x53, 0xcc, 0x3e, 0x83, 0x0d, 0xcc, 0xc3,
			0x44, 0x95, 0xd9, 0xba, 0xb1, 0x34, 0x5b, 0x0d, 0x2d, 0x8c, 0x1d, 0x3d, 0x7e, 0xaa, 0x02, 0x19,
			0xb9, 0x8c, 0xce, 0xae, 0x04, 0xec, 0x1e, 0xdc, 0x2c, 0x41, 0xad, 0xc6, 0x37, 0x49, 0x6f, 0xd9,
			0x96, 0xf7, 0x43, 0x1b, 0xd6, 0x2d, 0xef, 0x0e, 0x22, 0x35, 0x0b, 0xde, 0x43, 0xbe, 0xc5, 0xe2,
			0xb6, 0x3e, 0x58, 0xdc, 0x06, 0xd1, 0xda, 0x57, 0x89, 0xb6, 0x9c, 0xa0, 0x8b, 0x24, 0xeb, 0x5c,
			0x21, 0x99, 0x4d, 0x81, 0x29, 0xbf, 0x21, 0x68, 0x25, 0x28, 0xc8, 0x43, 0xe0, 0x7e, 0x49, 0xd1,
			0x52, 0xd2, 0x20, 0xd7, 0xea, 0x15, 0x72, 0xb9, 0xd0, 0x1b, 0x67, 0x22, 0x96, 0x27, 0xca, 0x92,
			0xb2, 0x80, 0x68, 0x17, 0x47, 0x9c, 0xa9, 0xbf, 0x61, 0x65, 0x25, 0xb0, 0x77, 0x4b, 0x51, 0x75,
			0xc3, 0xca, 0x9a, 0x84, 0x79, 0xb0, 0x3e, 0xc9, 0xc4, 0x9c, 0x46, 0x55, 0x24, 0x26, 0x96, 0x9a,
			0x0b, 0x32, 0xb4, 0xed, 0x4f, 0x45, 0x76, 0x32, 0x8b, 0x2d, 0x3b, 0x0b, 0xe8, 0xfd, 0xd8, 0x81,
			0x0d, 0x5b, 0xa6, 0x33, 0x39, 0x0d, 0xfd, 0xc8, 0xa4, 0x89, 0x44, 0x74, 0x9c, 0x63, 0x03, 0x29,
			0x25, 0xb5, 0xa9, 0xd0, 0x5a, 0x3e, 0x15, 0xda, 0xf5, 0xa4, 0xd7, 0xca, 0xbe, 0xb2, 0x58, 0xf6,
			0x0f, 0xcf, 0x0b, 0xea, 0x2a, 0xeb, 0x77, 0xb7, 0xe8, 0x2a, 0x83, 0xa9, 0x23, 0x70, 0x5d, 0x3b,
			0xa1, 0x37, 0x68, 0x0f, 0x3b, 0xbc, 0x29, 0xfe, 0xcb, 0xb3, 0xe3, 0x01, 0x5c, 0xcf, 0x7c, 0x6a,
			0x6c, 0xfb, 0x97, 0xfe, 0xd2, 0xbf, 0x2c, 0x2a, 0x61, 0x34, 0x2f, 0x4d, 0x02, 0x29, 0x07, 0x40,
			0xb1, 0xd6, 0x45, 0x58, 0x28, 0x0b, 0xf7, 0x33, 0x91, 0x04, 0x54, 0xca, 0x3e, 0x5f, 0x90, 0x61,
			0xee, 0x2d, 0x7e, 0x3e, 0x1b, 0x51, 0x29, 0xfb, 0xbc, 0x26, 0xa9, 0x9d, 0x81, 0x47, 0xde, 0xa7,
			0x6a, 0x56, 0x67, 0x90, 0x8c, 0x88, 0xf6, 0x32, 0xc0, 0x04, 0xd0, 0xb8, 0x69, 0xf1, 0x02, 0x12,
			0x95, 0x70, 0x61, 0xd2, 0xb5, 0x69, 0xde, 0xf5, 0x95, 0x84, 0xfd, 0x1f, 0xb6, 0x92, 0xb3, 0xd2,
			0x98, 0x19, 0x05, 0x5b, 0x94, 0xf7, 0x2b, 0x72, 0x9a, 0x5c, 0x67, 0x85, 0xeb, 0x44, 0xcd, 0x1b,
			0xa4, 0xd9, 0x90, 0xd6, 0xf5, 0x6c, 0xeb, 0xb0, 0x45, 0x3d, 0xdb, 0x3e, 0x4d, 0xbd, 0x3d, 0x1a,
			0x2e, 0x4d, 0xbd, 0x3d, 0xef, 0x21, 0x5c, 0xb7, 0x7c, 0xb5, 0x9f, 0x1f, 0xf7, 0xca, 0xd7, 0x89,
			0xb9, 0x52, 0xdd, 0xda, 0x5b, 0x6f, 0x81, 0xd8, 0xc5, 0x0b, 0xc5, 0xfb, 0xc9, 0x01, 0x78, 0x32,
			0x8b, 0x45, 0xf2, 0x22, 0x13, 0xfe, 0x05, 0x3e, 0x17, 0x22, 0x39, 0xd6, 0x96, 0xe9, 0xb4, 0x46,
			0x2e, 0x67, 0xb5, 0xaf, 0x36, 0x03, 0xe8, 0xf5, 0xa5, 0x52, 0xcb, 0x6f, 0x5c, 0xd2, 0xd7, 0x8b,
			0xd2, 0x5a, 0xc5, 0xe5, 0xd7, 0x0b, 0xa1, 0xc6, 0x17, 0x54, 0xa7, 0xf9, 0x05, 0xc5, 0xd6, 0xc1,
			0xb9, 0xb4, 0x94, 0x76, 0x2e, 0x11, 0x15, 0x4f, 0x4a, 0x67, 0x6e, 0xef, 0x7b, 0x33, 0x40, 0xf0,
			0xbe, 0xc7, 0x7a, 0x9a, 0x37, 0x88, 0xdb, 0x1f, 0xb4, 0xa9, 0x9e, 0x06, 0x7a, 0x67, 0xb0, 0x55,
			0xc5, 0x61, 0xd3, 0x71, 0xb7, 0x91, 0x8e, 0xda, 0x63, 0xad, 0xa6, 0x5b, 0x7b, 0xac, 0xf9, 0x6a,
			0x96, 0x94, 0x71, 0x12, 0xf0, 0xbe, 0x84, 0x5b, 0xcd, 0x73, 0x8f, 0x45, 0xae, 0xd9, 0x5e, 0xe3,
			0xec, 0xed, 0xa5, 0x67, 0x2f, 0x3c, 0x07, 0xf7, 0xdd, 0x9f, 0xdf, 0xec, 0x38, 0xaf, 0xdf, 0xec,
			0x38, 0xbf, 0xbe, 0xd9, 0x71, 0xbe, 0x7f, 0xbb, 0x73, 0xed, 0xf5, 0xdb, 0x9d, 0x6b, 0xbf, 0xbc,
			0xdd, 0xb9, 0x36, 0xea, 0xd2, 0x9f, 0x3f, 0xfd, 0x33, 0x00, 0x00, 0xff, 0xff, 0x74, 0xb1, 0xca,
			0x5e, 0x64, 0x0f, 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) {
			@@ -1782,6 +1961,174 @@
			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
			}
			@@ -1887,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
			@@ -1981,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
			@@ -2075,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
			@@ -2119,21 +2466,21 @@
			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
			n15, err15 := m.Pos.MarshalTo(dAtA[i:])
			if err15 != nil {
			return 0, err15
			}
			i += n14
			i += n15
			}
			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
			n16, err16 := m.Result.MarshalTo(dAtA[i:])
			if err16 != nil {
			return 0, err16
			}
			i += n15
			i += n16
			}
			if len(m.Feats) > 0 {
			dAtA[i] = 0x1a
			@@ -2205,11 +2552,11 @@
			dAtA[i] = 0x1a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
			n16, err16 := m.Pos.MarshalTo(dAtA[i:])
			if err16 != nil {
			return 0, err16
			n17, err17 := m.Pos.MarshalTo(dAtA[i:])
			if err17 != nil {
			return 0, err17
			}
			i += n16
			i += n17
			}
			return i, nil
			}
			@@ -2366,11 +2713,11 @@
			dAtA[i] = 0x42
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
			n17, err17 := m.RcLocation.MarshalTo(dAtA[i:])
			if err17 != nil {
			return 0, err17
			n18, err18 := m.RcLocation.MarshalTo(dAtA[i:])
			if err18 != nil {
			return 0, err18
			}
			i += n17
			i += n18
			}
			if m.NTime != 0 {
			dAtA[i] = 0x48
			@@ -2423,11 +2770,11 @@
			dAtA[i] = 0x1
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLogoLocation.Size()))
			n18, err18 := m.RcLogoLocation.MarshalTo(dAtA[i:])
			if err18 != nil {
			return 0, err18
			n19, err19 := m.RcLogoLocation.MarshalTo(dAtA[i:])
			if err19 != nil {
			return 0, err19
			}
			i += n18
			i += n19
			}
			if len(m.NCarModel) > 0 {
			dAtA[i] = 0x92
			@@ -2473,11 +2820,11 @@
			dAtA[i] = 0x12
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
			n19, err19 := m.RcLocation.MarshalTo(dAtA[i:])
			if err19 != nil {
			return 0, err19
			n20, err20 := m.RcLocation.MarshalTo(dAtA[i:])
			if err20 != nil {
			return 0, err20
			}
			i += n19
			i += n20
			}
			if m.NConfidence != 0 {
			dAtA[i] = 0x18
			@@ -2584,42 +2931,42 @@
			i = encodeVarintSdk(dAtA, i, uint64(m.NCharNum))
			}
			if len(m.NCharConfidence) > 0 {
			dAtA21 := make([]byte, len(m.NCharConfidence)*10)
			var j20 int
			dAtA22 := make([]byte, len(m.NCharConfidence)*10)
			var j21 int
			for _, num1 := range m.NCharConfidence {
			num := uint64(num1)
			for num >= 1<<7 {
			dAtA21[j20] = uint8(uint64(num)&0x7f \| 0x80)
			dAtA22[j21] = uint8(uint64(num)&0x7f \| 0x80)
			num >>= 7
			j20++
			j21++
			}
			dAtA21[j20] = uint8(num)
			j20++
			dAtA22[j21] = uint8(num)
			j21++
			}
			dAtA[i] = 0x3a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(j20))
			i += copy(dAtA[i:], dAtA21[:j20])
			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()))
			n22, err22 := m.RcLocation.MarshalTo(dAtA[i:])
			if err22 != nil {
			return 0, err22
			n23, err23 := m.RcLocation.MarshalTo(dAtA[i:])
			if err23 != nil {
			return 0, err23
			}
			i += n22
			i += n23
			}
			if m.RcCarLocation != nil {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.RcCarLocation.Size()))
			n23, err23 := m.RcCarLocation.MarshalTo(dAtA[i:])
			if err23 != nil {
			return 0, err23
			n24, err24 := m.RcCarLocation.MarshalTo(dAtA[i:])
			if err24 != nil {
			return 0, err24
			}
			i += n23
			i += n24
			}
			if len(m.VehicleType) > 0 {
			dAtA[i] = 0x52
			@@ -2733,54 +3080,44 @@
			_ = i
			var l int
			_ = l
			if m.Left != 0 {
			dAtA[i] = 0x8
			if m.RcHuman != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Left))
			}
			if m.Right != 0 {
			dAtA[i] = 0x10
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Right))
			}
			if m.Top != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Top))
			}
			if m.Bottom != 0 {
			dAtA[i] = 0x20
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Bottom))
			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] = 0x2d
			dAtA[i] = 0x15
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
			i += 4
			}
			if m.X != 0 {
			dAtA[i] = 0x30
			dAtA[i] = 0x18
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.X))
			}
			if m.Y != 0 {
			dAtA[i] = 0x38
			dAtA[i] = 0x20
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Y))
			}
			if m.Id != 0 {
			dAtA[i] = 0x40
			dAtA[i] = 0x28
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Id))
			}
			if len(m.Feature) > 0 {
			dAtA[i] = 0x4a
			dAtA[i] = 0x32
			i++
			i = encodeVarintSdk(dAtA, i, uint64(len(m.Feature)*4))
			for _, num := range m.Feature {
			f24 := math.Float32bits(float32(num))
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f24))
			f26 := math.Float32bits(float32(num))
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f26))
			i += 4
			}
			}
			@@ -2798,41 +3135,6 @@
			}

			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
			}
			}
			if m.Count != 0 {
			dAtA[i] = 0x10
			i++
			i = encodeVarintSdk(dAtA, i, uint64(m.Count))
			}
			return i, nil
			}

			func (m *HumanTrackResultLast) 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 *HumanTrackResultLast) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			@@ -2887,6 +3189,101 @@
			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
			}
			@@ -3375,17 +3772,9 @@
			}
			var l int
			_ = l
			if m.Left != 0 {
			n += 1 + sovSdk(uint64(m.Left))
			}
			if m.Right != 0 {
			n += 1 + sovSdk(uint64(m.Right))
			}
			if m.Top != 0 {
			n += 1 + sovSdk(uint64(m.Top))
			}
			if m.Bottom != 0 {
			n += 1 + sovSdk(uint64(m.Bottom))
			if m.RcHuman != nil {
			l = m.RcHuman.Size()
			n += 1 + l + sovSdk(uint64(l))
			}
			if m.Confidence != 0 {
			n += 5
			@@ -3406,24 +3795,6 @@
			}

			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))
			}
			}
			if m.Count != 0 {
			n += 1 + sovSdk(uint64(m.Count))
			}
			return n
			}

			func (m *HumanTrackResultLast) Size() (n int) {
			if m == nil {
			return 0
			}
			@@ -3634,6 +4005,669 @@
			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:])
			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 *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
			@@ -7024,10 +8058,10 @@
			}
			switch fieldNum {
			case 1:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RcHuman", wireType)
			}
			m.Left = 0
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			@@ -7037,69 +8071,29 @@
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Left \|= int32(b&0x7F) << shift
			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 != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
			}
			m.Right = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Right \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 3:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Top", wireType)
			}
			m.Top = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Top \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Bottom", wireType)
			}
			m.Bottom = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Bottom \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 5:
			if wireType != 5 {
			return fmt.Errorf("proto: wrong wireType = %d for field Confidence", wireType)
			}
			@@ -7110,7 +8104,7 @@
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Confidence = float32(math.Float32frombits(v))
			case 6:
			case 3:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
			}
			@@ -7129,7 +8123,7 @@
			break
			}
			}
			case 7:
			case 4:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
			}
			@@ -7148,7 +8142,7 @@
			break
			}
			}
			case 8:
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			@@ -7167,7 +8161,7 @@
			break
			}
			}
			case 9:
			case 6:
			if wireType == 5 {
			var v uint32
			if (iNdEx + 4) > l {
			@@ -7304,112 +8298,6 @@
			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
			case 2:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowSdk
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Count \|= 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 *HumanTrackResultLast) 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: HumanTrackResultLast: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: HumanTrackResultLast: 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, &HumanTrackResult{})
			if err := m.Result[len(m.Result)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}