update BaseInfo

liuxiaolong

2019-11-19 3e7fd5950d794150c2045b6fc2d764f72602c94e

 sdk.pb.go

@@ -29,6 +29,7 @@
   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"`
}

func (m *Image) Reset()         { *m = Image{} }
@@ -97,6 +98,13 @@
      return m.Id
   }
   return 0
}

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

type FaceAngle struct {
@@ -252,6 +260,7 @@
   FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
   Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
   FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
   FaceID     uint64     `protobuf:"varint,9,opt,name=faceID,proto3" json:"faceID,omitempty"`
}

func (m *FacePos) Reset()         { *m = FacePos{} }
@@ -341,6 +350,13 @@
      return m.FacialData
   }
   return nil
}

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

type FaceInfo struct {
@@ -455,6 +471,7 @@
   RcObj *Rect   `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
   Typ   int32   `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
   Prob  float32 `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
   ObjID uint64  `protobuf:"varint,4,opt,name=objID,proto3" json:"objID,omitempty"`
}

func (m *ObjInfo) Reset()         { *m = ObjInfo{} }
@@ -511,10 +528,18 @@
   return 0
}

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

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

func (m *ResultFaceDetect) Reset()         { *m = ResultFaceDetect{} }
@@ -560,6 +585,13 @@
func (m *ResultFaceDetect) GetResult() *ThftResult {
   if m != nil {
      return m.Result
   }
   return nil
}

func (m *ResultFaceDetect) GetFeats() []byte {
   if m != nil {
      return m.Feats
   }
   return nil
}
@@ -757,6 +789,484 @@
   return nil
}

type SoInfo struct {
   Id     string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   SdkId  string `protobuf:"bytes,2,opt,name=sdkId,proto3" json:"sdkId,omitempty"`
   SoName string `protobuf:"bytes,3,opt,name=soName,proto3" json:"soName,omitempty"`
}

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

var xxx_messageInfo_SoInfo proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_PlateID proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type PlateIDResult struct {
   Result []*PlateID `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}
}
func (m *PlateIDResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *PlateIDResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_PlateIDResult.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *PlateIDResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_PlateIDResult.Merge(m, src)
}
func (m *PlateIDResult) XXX_Size() int {
   return m.Size()
}
func (m *PlateIDResult) XXX_DiscardUnknown() {
   xxx_messageInfo_PlateIDResult.DiscardUnknown(m)
}

var xxx_messageInfo_PlateIDResult proto.InternalMessageInfo

func (m *PlateIDResult) GetResult() []*PlateID {
   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"`
}

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

var xxx_messageInfo_PlateCloudID proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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 {
   return m.Unmarshal(b)
}
func (m *PlateCloudIDResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_PlateCloudIDResult.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 *PlateCloudIDResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_PlateCloudIDResult.Merge(m, src)
}
func (m *PlateCloudIDResult) XXX_Size() int {
   return m.Size()
}
func (m *PlateCloudIDResult) XXX_DiscardUnknown() {
   xxx_messageInfo_PlateCloudIDResult.DiscardUnknown(m)
}

var xxx_messageInfo_PlateCloudIDResult proto.InternalMessageInfo

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

func init() {
   proto.RegisterType((*Image)(nil), "protomsg.Image")
   proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
@@ -769,54 +1279,88 @@
   proto.RegisterType((*ResultFaceExtCom)(nil), "protomsg.ResultFaceExtCom")
   proto.RegisterType((*ParamFaceFeature)(nil), "protomsg.ParamFaceFeature")
   proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
   proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
   proto.RegisterType((*PlateID)(nil), "protomsg.PlateID")
   proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
   proto.RegisterType((*PlateCloudID)(nil), "protomsg.PlateCloudID")
   proto.RegisterType((*PlateCloudIDResult)(nil), "protomsg.PlateCloudIDResult")
}

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

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -860,6 +1404,12 @@
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Id))
   }
   if len(m.Cid) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Cid)))
      i += copy(dAtA[i:], m.Cid)
   }
   return i, nil
}
@@ -1032,6 +1582,11 @@
      i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
      i += copy(dAtA[i:], m.FacialData)
   }
   if m.FaceID != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
   }
   return i, nil
}

@@ -1165,6 +1720,11 @@
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
      i += 4
   }
   if m.ObjID != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.ObjID))
   }
   return i, nil
}

@@ -1202,6 +1762,12 @@
         return 0, err15
      }
      i += n15
   }
   if len(m.Feats) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
      i += copy(dAtA[i:], m.Feats)
   }
   return i, nil
}
@@ -1336,6 +1902,329 @@
   return i, nil
}

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

func (m *SoInfo) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.SdkId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkId)))
      i += copy(dAtA[i:], m.SdkId)
   }
   if len(m.SoName) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.SoName)))
      i += copy(dAtA[i:], m.SoName)
   }
   return i, nil
}

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

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

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

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

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

func (m *PlateCloudIDResult) 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 *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 encodeVarintSdk(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1367,6 +2256,10 @@
   }
   if m.Id != 0 {
      n += 1 + sovSdk(uint64(m.Id))
   }
   l = len(m.Cid)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   return n
}
@@ -1453,6 +2346,9 @@
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   if m.FaceID != 0 {
      n += 1 + sovSdk(uint64(m.FaceID))
   }
   return n
}

@@ -1515,6 +2411,9 @@
   if m.Prob != 0 {
      n += 5
   }
   if m.ObjID != 0 {
      n += 1 + sovSdk(uint64(m.ObjID))
   }
   return n
}

@@ -1530,6 +2429,10 @@
   }
   if m.Result != nil {
      l = m.Result.Size()
      n += 1 + l + sovSdk(uint64(l))
   }
   l = len(m.Feats)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   return n
@@ -1594,6 +2497,182 @@
   _ = l
   if len(m.Infos) > 0 {
      for _, e := range m.Infos {
         l = e.Size()
         n += 1 + l + sovSdk(uint64(l))
      }
   }
   return n
}

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

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

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

func (m *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))
      }
@@ -1766,6 +2845,38 @@
               break
            }
         }
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Cid = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
@@ -2357,6 +3468,25 @@
            m.FacialData = []byte{}
         }
         iNdEx = postIndex
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceID", wireType)
         }
         m.FaceID = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FaceID |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
@@ -2817,6 +3947,25 @@
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.Prob = float32(math.Float32frombits(v))
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ObjID", wireType)
         }
         m.ObjID = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ObjID |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
@@ -2940,6 +4089,40 @@
         }
         if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Feats", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Feats = append(m.Feats[:0], dAtA[iNdEx:postIndex]...)
         if m.Feats == nil {
            m.Feats = []byte{}
         }
         iNdEx = postIndex
      default:
@@ -3384,6 +4567,1208 @@
   }
   return nil
}
func (m *SoInfo) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowSdk
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: SoInfo: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SoInfo: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SdkId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.SdkId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SoName", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.SoName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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

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

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *PlateCloudIDResult) 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: PlateCloudIDResult: 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 skipSdk(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0