更新dataprocess.pb

zhangzengfei

2024-05-08 80ae7958a17a492098f18f31fa21804f37b6cbaa

 sdk.pb.go

@@ -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)
@@ -1038,15 +1282,346 @@
   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 {
   Result []*PlateID `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
   // 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{13}
   return fileDescriptor_70decb0fb6f436df, []int{18}
}
func (m *PlateIDResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1075,42 +1650,34 @@

var xxx_messageInfo_PlateIDResult proto.InternalMessageInfo

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

// cloud
type PlateCloudID 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"`
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 *PlateCloudID) Reset()         { *m = PlateCloudID{} }
func (m *PlateCloudID) String() string { return proto.CompactTextString(m) }
func (*PlateCloudID) ProtoMessage()    {}
func (*PlateCloudID) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{14}
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 *PlateCloudID) XXX_Unmarshal(b []byte) error {
func (m *HumanTrack) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *PlateCloudID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *HumanTrack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_PlateCloudID.Marshal(b, m, deterministic)
      return xxx_messageInfo_HumanTrack.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
@@ -1120,125 +1687,76 @@
      return b[:n], nil
   }
}
func (m *PlateCloudID) XXX_Merge(src proto.Message) {
   xxx_messageInfo_PlateCloudID.Merge(m, src)
func (m *HumanTrack) XXX_Merge(src proto.Message) {
   xxx_messageInfo_HumanTrack.Merge(m, src)
}
func (m *PlateCloudID) XXX_Size() int {
func (m *HumanTrack) XXX_Size() int {
   return m.Size()
}
func (m *PlateCloudID) XXX_DiscardUnknown() {
   xxx_messageInfo_PlateCloudID.DiscardUnknown(m)
func (m *HumanTrack) XXX_DiscardUnknown() {
   xxx_messageInfo_HumanTrack.DiscardUnknown(m)
}

var xxx_messageInfo_PlateCloudID proto.InternalMessageInfo
var xxx_messageInfo_HumanTrack proto.InternalMessageInfo

func (m *PlateCloudID) GetLicense() string {
func (m *HumanTrack) GetRcHuman() *Rect {
   if m != nil {
      return m.License
   }
   return ""
}

func (m *PlateCloudID) GetRcLocation() *Rect {
   if m != nil {
      return m.RcLocation
      return m.RcHuman
   }
   return nil
}

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

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

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

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

func (m *PlateCloudID) GetNCarColor1() int32 {
func (m *HumanTrack) GetFeature() []float32 {
   if m != nil {
      return m.NCarColor1
      return m.Feature
   }
   return 0
   return nil
}

func (m *PlateCloudID) GetNCarBright() int32 {
   if m != nil {
      return m.NCarBright
   }
   return 0
type HumanTrackResult struct {
   Result []*HumanTrack `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
}

func (m *PlateCloudID) GetFrameNo() int32 {
   if m != nil {
      return m.FrameNo
   }
   return 0
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 *PlateCloudID) GetFaceWidth() int32 {
   if m != nil {
      return m.FaceWidth
   }
   return 0
}

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

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

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

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

func (m *PlateCloudIDResult) Reset()         { *m = PlateCloudIDResult{} }
func (m *PlateCloudIDResult) String() string { return proto.CompactTextString(m) }
func (*PlateCloudIDResult) ProtoMessage()    {}
func (*PlateCloudIDResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{15}
}
func (m *PlateCloudIDResult) XXX_Unmarshal(b []byte) error {
func (m *HumanTrackResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *PlateCloudIDResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *HumanTrackResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_PlateCloudIDResult.Marshal(b, m, deterministic)
      return xxx_messageInfo_HumanTrackResult.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
@@ -1248,251 +1766,19 @@
      return b[:n], nil
   }
}
func (m *PlateCloudIDResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_PlateCloudIDResult.Merge(m, src)
func (m *HumanTrackResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_HumanTrackResult.Merge(m, src)
}
func (m *PlateCloudIDResult) XXX_Size() int {
func (m *HumanTrackResult) XXX_Size() int {
   return m.Size()
}
func (m *PlateCloudIDResult) XXX_DiscardUnknown() {
   xxx_messageInfo_PlateCloudIDResult.DiscardUnknown(m)
func (m *HumanTrackResult) XXX_DiscardUnknown() {
   xxx_messageInfo_HumanTrackResult.DiscardUnknown(m)
}

var xxx_messageInfo_PlateCloudIDResult proto.InternalMessageInfo
var xxx_messageInfo_HumanTrackResult proto.InternalMessageInfo

func (m *PlateCloudIDResult) GetResult() []*PlateCloudID {
   if m != nil {
      return m.Result
   }
   return nil
}

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

var xxx_messageInfo_PlateVehicleID proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var xxx_messageInfo_PlateVehicleIDResult proto.InternalMessageInfo

func (m *PlateVehicleIDResult) GetResult() []*PlateVehicleID {
func (m *HumanTrackResult) GetResult() []*HumanTrack {
   if m != nil {
      return m.Result
   }
@@ -1501,6 +1787,9 @@

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")
@@ -1513,101 +1802,116 @@
   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((*PlateCloudID)(nil), "protomsg.PlateCloudID")
   proto.RegisterType((*PlateCloudIDResult)(nil), "protomsg.PlateCloudIDResult")
   proto.RegisterType((*PlateVehicleID)(nil), "protomsg.PlateVehicleID")
   proto.RegisterType((*PlateVehicleIDResult)(nil), "protomsg.PlateVehicleIDResult")
   proto.RegisterType((*HumanTrack)(nil), "protomsg.HumanTrack")
   proto.RegisterType((*HumanTrackResult)(nil), "protomsg.HumanTrackResult")
}

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

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

func (m *PlateIDResult) Marshal() (dAtA []byte, err error) {
func (m *PlateIDCloud) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -2333,37 +2805,7 @@
   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 *PlateCloudID) 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 *PlateCloudID) MarshalTo(dAtA []byte) (int, error) {
func (m *PlateIDCloud) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2378,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
@@ -2442,7 +2884,7 @@
   return i, nil
}

func (m *PlateCloudIDResult) Marshal() (dAtA []byte, err error) {
func (m *PlateIDVehicle) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -2452,37 +2894,7 @@
   return dAtA[:n], nil
}

func (m *PlateCloudIDResult) 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 *PlateVehicleID) 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 *PlateVehicleID) MarshalTo(dAtA []byte) (int, error) {
func (m *PlateIDVehicle) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2519,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
@@ -2623,7 +3035,7 @@
   return i, nil
}

func (m *PlateVehicleIDResult) Marshal() (dAtA []byte, err error) {
func (m *PlateIDResult) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -2633,7 +3045,96 @@
   return dAtA[:n], nil
}

func (m *PlateVehicleIDResult) MarshalTo(dAtA []byte) (int, error) {
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
@@ -2688,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
}
@@ -3028,22 +3624,7 @@
   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 *PlateCloudID) Size() (n int) {
func (m *PlateIDCloud) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -3093,22 +3674,7 @@
   return n
}

func (m *PlateCloudIDResult) 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 *PlateVehicleID) Size() (n int) {
func (m *PlateIDVehicle) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -3185,7 +3751,50 @@
   return n
}

func (m *PlateVehicleIDResult) Size() (n int) {
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
   }
@@ -3396,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
@@ -5785,7 +7057,7 @@
   }
   return nil
}
func (m *PlateIDResult) Unmarshal(dAtA []byte) error {
func (m *PlateIDCloud) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -5808,97 +7080,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateIDResult: wiretype end group for non-group")
         return fmt.Errorf("proto: PlateIDCloud: 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, &PlateID{})
         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
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *PlateCloudID) 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: PlateCloudID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudID: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: PlateIDCloud: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6202,7 +7387,7 @@
   }
   return nil
}
func (m *PlateCloudIDResult) Unmarshal(dAtA []byte) error {
func (m *PlateIDVehicle) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -6225,97 +7410,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateCloudIDResult: wiretype end group for non-group")
         return fmt.Errorf("proto: PlateIDVehicle: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudIDResult: 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, &PlateCloudID{})
         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
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *PlateVehicleID) 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: PlateVehicleID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateVehicleID: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: PlateIDVehicle: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6843,7 +7941,7 @@
   }
   return nil
}
func (m *PlateVehicleIDResult) Unmarshal(dAtA []byte) error {
func (m *PlateIDResult) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -6866,10 +7964,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateVehicleIDResult: wiretype end group for non-group")
         return fmt.Errorf("proto: PlateIDResult: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateVehicleIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: PlateIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6901,7 +7999,305 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Result = append(m.Result, &PlateVehicleID{})
         m.Result = append(m.Result, &PlateIDVehicle{})
         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
      }
   }

   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
         }