update BaseInfo

liuxiaolong

2019-11-19 3e7fd5950d794150c2045b6fc2d764f72602c94e

 sdk.pb.go

@@ -1,11 +1,13 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: sdk.proto

package protomsg

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

@@ -18,19 +20,16 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// Image ipc struct
type Image struct {
   Width                int32    `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
   Height               int32    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
   Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
   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"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   Width     int32  `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
   Height    int32  `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
   Data      []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
   Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
   Id        int64  `protobuf:"varint,5,opt,name=id,proto3" json:"id,omitempty"`
   Cid       string `protobuf:"bytes,6,opt,name=cid,proto3" json:"cid,omitempty"`
}

func (m *Image) Reset()         { *m = Image{} }
@@ -39,18 +38,26 @@
func (*Image) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{0}
}

func (m *Image) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_Image.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_Image.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_Image.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *Image) XXX_Merge(src proto.Message) {
   xxx_messageInfo_Image.Merge(m, src)
}
func (m *Image) XXX_Size() int {
   return xxx_messageInfo_Image.Size(m)
   return m.Size()
}
func (m *Image) XXX_DiscardUnknown() {
   xxx_messageInfo_Image.DiscardUnknown(m)
@@ -101,13 +108,10 @@
}

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

func (m *FaceAngle) Reset()         { *m = FaceAngle{} }
@@ -116,18 +120,26 @@
func (*FaceAngle) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{1}
}

func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_FaceAngle.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *FaceAngle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_FaceAngle.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_FaceAngle.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *FaceAngle) XXX_Merge(src proto.Message) {
   xxx_messageInfo_FaceAngle.Merge(m, src)
}
func (m *FaceAngle) XXX_Size() int {
   return xxx_messageInfo_FaceAngle.Size(m)
   return m.Size()
}
func (m *FaceAngle) XXX_DiscardUnknown() {
   xxx_messageInfo_FaceAngle.DiscardUnknown(m)
@@ -164,14 +176,11 @@
}

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

func (m *ThftResult) Reset()         { *m = ThftResult{} }
@@ -180,18 +189,26 @@
func (*ThftResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{2}
}

func (m *ThftResult) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ThftResult.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ThftResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ThftResult.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ThftResult.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *ThftResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ThftResult.Merge(m, src)
}
func (m *ThftResult) XXX_Size() int {
   return xxx_messageInfo_ThftResult.Size(m)
   return m.Size()
}
func (m *ThftResult) XXX_DiscardUnknown() {
   xxx_messageInfo_ThftResult.DiscardUnknown(m)
@@ -235,18 +252,15 @@
}

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

func (m *FacePos) Reset()         { *m = FacePos{} }
@@ -255,18 +269,26 @@
func (*FacePos) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{3}
}

func (m *FacePos) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_FacePos.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *FacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_FacePos.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_FacePos.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *FacePos) XXX_Merge(src proto.Message) {
   xxx_messageInfo_FacePos.Merge(m, src)
}
func (m *FacePos) XXX_Size() int {
   return xxx_messageInfo_FacePos.Size(m)
   return m.Size()
}
func (m *FacePos) XXX_DiscardUnknown() {
   xxx_messageInfo_FacePos.DiscardUnknown(m)
@@ -338,18 +360,15 @@
}

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

func (m *FaceInfo) Reset()         { *m = FaceInfo{} }
@@ -358,18 +377,26 @@
func (*FaceInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{4}
}

func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_FaceInfo.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *FaceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_FaceInfo.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_FaceInfo.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *FaceInfo) XXX_Merge(src proto.Message) {
   xxx_messageInfo_FaceInfo.Merge(m, src)
}
func (m *FaceInfo) XXX_Size() int {
   return xxx_messageInfo_FaceInfo.Size(m)
   return m.Size()
}
func (m *FaceInfo) XXX_DiscardUnknown() {
   xxx_messageInfo_FaceInfo.DiscardUnknown(m)
@@ -441,13 +468,10 @@
}

type ObjInfo struct {
   RcObj                *Rect    `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
   Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
   Prob                 float32  `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
   ObjID                uint64   `protobuf:"varint,4,opt,name=objID,proto3" json:"objID,omitempty"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   RcObj *Rect   `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
   Typ   int32   `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
   Prob  float32 `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
   ObjID uint64  `protobuf:"varint,4,opt,name=objID,proto3" json:"objID,omitempty"`
}

func (m *ObjInfo) Reset()         { *m = ObjInfo{} }
@@ -456,18 +480,26 @@
func (*ObjInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{5}
}

func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ObjInfo.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ObjInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ObjInfo.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ObjInfo.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *ObjInfo) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ObjInfo.Merge(m, src)
}
func (m *ObjInfo) XXX_Size() int {
   return xxx_messageInfo_ObjInfo.Size(m)
   return m.Size()
}
func (m *ObjInfo) XXX_DiscardUnknown() {
   xxx_messageInfo_ObjInfo.DiscardUnknown(m)
@@ -505,12 +537,9 @@

// 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"`
   XXX_NoUnkeyedLiteral struct{}    `json:"-"`
   XXX_unrecognized     []byte      `json:"-"`
   XXX_sizecache        int32       `json:"-"`
   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{} }
@@ -519,18 +548,26 @@
func (*ResultFaceDetect) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{6}
}

func (m *ResultFaceDetect) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ResultFaceDetect.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ResultFaceDetect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ResultFaceDetect.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ResultFaceDetect.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *ResultFaceDetect) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ResultFaceDetect.Merge(m, src)
}
func (m *ResultFaceDetect) XXX_Size() int {
   return xxx_messageInfo_ResultFaceDetect.Size(m)
   return m.Size()
}
func (m *ResultFaceDetect) XXX_DiscardUnknown() {
   xxx_messageInfo_ResultFaceDetect.DiscardUnknown(m)
@@ -560,10 +597,7 @@
}

type ParamFacePos struct {
   Faces                []*ResultFaceDetect `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
   XXX_NoUnkeyedLiteral struct{}            `json:"-"`
   XXX_unrecognized     []byte              `json:"-"`
   XXX_sizecache        int32               `json:"-"`
   Faces []*ResultFaceDetect `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
}

func (m *ParamFacePos) Reset()         { *m = ParamFacePos{} }
@@ -572,18 +606,26 @@
func (*ParamFacePos) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{7}
}

func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ParamFacePos.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ParamFacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ParamFacePos.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ParamFacePos.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 *ParamFacePos) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ParamFacePos.Merge(m, src)
}
func (m *ParamFacePos) XXX_Size() int {
   return xxx_messageInfo_ParamFacePos.Size(m)
   return m.Size()
}
func (m *ParamFacePos) XXX_DiscardUnknown() {
   xxx_messageInfo_ParamFacePos.DiscardUnknown(m)
@@ -599,12 +641,9 @@
}

type ResultFaceExtCom struct {
   Feats                []byte            `protobuf:"bytes,1,opt,name=feats,proto3" json:"feats,omitempty"`
   Comp                 []byte            `protobuf:"bytes,2,opt,name=comp,proto3" json:"comp,omitempty"`
   Pos                  *ResultFaceDetect `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
   XXX_NoUnkeyedLiteral struct{}          `json:"-"`
   XXX_unrecognized     []byte            `json:"-"`
   XXX_sizecache        int32             `json:"-"`
   Feats []byte            `protobuf:"bytes,1,opt,name=feats,proto3" json:"feats,omitempty"`
   Comp  []byte            `protobuf:"bytes,2,opt,name=comp,proto3" json:"comp,omitempty"`
   Pos   *ResultFaceDetect `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
}

func (m *ResultFaceExtCom) Reset()         { *m = ResultFaceExtCom{} }
@@ -613,18 +652,26 @@
func (*ResultFaceExtCom) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{8}
}

func (m *ResultFaceExtCom) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ResultFaceExtCom.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ResultFaceExtCom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ResultFaceExtCom.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ResultFaceExtCom.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 *ResultFaceExtCom) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ResultFaceExtCom.Merge(m, src)
}
func (m *ResultFaceExtCom) XXX_Size() int {
   return xxx_messageInfo_ResultFaceExtCom.Size(m)
   return m.Size()
}
func (m *ResultFaceExtCom) XXX_DiscardUnknown() {
   xxx_messageInfo_ResultFaceExtCom.DiscardUnknown(m)
@@ -654,10 +701,7 @@
}

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

func (m *ParamFaceFeature) Reset()         { *m = ParamFaceFeature{} }
@@ -666,18 +710,26 @@
func (*ParamFaceFeature) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{9}
}

func (m *ParamFaceFeature) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ParamFaceFeature.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ParamFaceFeature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ParamFaceFeature.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ParamFaceFeature.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *ParamFaceFeature) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ParamFaceFeature.Merge(m, src)
}
func (m *ParamFaceFeature) XXX_Size() int {
   return xxx_messageInfo_ParamFaceFeature.Size(m)
   return m.Size()
}
func (m *ParamFaceFeature) XXX_DiscardUnknown() {
   xxx_messageInfo_ParamFaceFeature.DiscardUnknown(m)
@@ -694,10 +746,7 @@

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

func (m *ParamYoloObj) Reset()         { *m = ParamYoloObj{} }
@@ -706,18 +755,26 @@
func (*ParamYoloObj) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{10}
}

func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ParamYoloObj.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ParamYoloObj) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ParamYoloObj.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ParamYoloObj.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 *ParamYoloObj) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ParamYoloObj.Merge(m, src)
}
func (m *ParamYoloObj) XXX_Size() int {
   return xxx_messageInfo_ParamYoloObj.Size(m)
   return m.Size()
}
func (m *ParamYoloObj) XXX_DiscardUnknown() {
   xxx_messageInfo_ParamYoloObj.DiscardUnknown(m)
@@ -733,12 +790,9 @@
}

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"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   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{} }
@@ -747,18 +801,26 @@
func (*SoInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{11}
}

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

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

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

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

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

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

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

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

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

func (m *FaceInfo) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.RcFace != nil {
      dAtA[i] = 0xa
      i++
      i = 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:])
      if err8 != nil {
         return 0, err8
      }
      i += n8
   }
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
      n9, err9 := m.PtRightEye.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n9
   }
   if m.PtMouth != nil {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
      n10, err10 := m.PtMouth.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      }
      i += n10
   }
   if m.PtNose != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtNose.Size()))
      n11, err11 := m.PtNose.MarshalTo(dAtA[i:])
      if err11 != nil {
         return 0, err11
      }
      i += n11
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FAngle.Size()))
      n12, err12 := m.FAngle.MarshalTo(dAtA[i:])
      if err12 != nil {
         return 0, err12
      }
      i += n12
   }
   if m.Quality != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Quality))
   }
   if len(m.FacialData) > 0 {
      dAtA[i] = 0x42
      i++
      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
}

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

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

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

func (m *ResultFaceDetect) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Pos != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
      n14, err14 := m.Pos.MarshalTo(dAtA[i:])
      if err14 != nil {
         return 0, err14
      }
      i += n14
   }
   if m.Result != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Result.Size()))
      n15, err15 := m.Result.MarshalTo(dAtA[i:])
      if err15 != nil {
         return 0, err15
      }
      i += n15
   }
   if 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
}

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

func (m *ResultFaceExtCom) 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 *ResultFaceExtCom) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Feats) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
      i += copy(dAtA[i:], m.Feats)
   }
   if len(m.Comp) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Comp)))
      i += copy(dAtA[i:], m.Comp)
   }
   if m.Pos != nil {
      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
      }
      i += n16
   }
   return i, nil
}

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

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

func (m *ParamYoloObj) 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 *ParamYoloObj) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Infos) > 0 {
      for _, msg := range m.Infos {
         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 *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)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return offset + 1
}
func (m *Image) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Width != 0 {
      n += 1 + sovSdk(uint64(m.Width))
   }
   if m.Height != 0 {
      n += 1 + sovSdk(uint64(m.Height))
   }
   l = len(m.Data)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   l = len(m.Timestamp)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   if m.Id != 0 {
      n += 1 + sovSdk(uint64(m.Id))
   }
   l = len(m.Cid)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   return n
}

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

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

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

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

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

func (m *ResultFaceDetect) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Pos != nil {
      l = m.Pos.Size()
      n += 1 + l + sovSdk(uint64(l))
   }
   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
}

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

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

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

func (m *ParamYoloObj) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = 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))
      }
   }
   return n
}

func sovSdk(x uint64) (n int) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
   }
   return n
}
func sozSdk(x uint64) (n int) {
   return sovSdk(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Image) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 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: Image: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
         }
         m.Width = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Width |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
         }
         m.Height = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Height |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
         if m.Data == nil {
            m.Data = []byte{}
         }
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Timestamp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         m.Id = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Id |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Cid = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      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 *FaceAngle) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 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: FaceAngle: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: FaceAngle: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Yaw", wireType)
         }
         m.Yaw = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Yaw |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Pitch", wireType)
         }
         m.Pitch = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Pitch |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Roll", wireType)
         }
         m.Roll = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Roll |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field Confidence", wireType)
         }
         var v uint32
         if (iNdEx + 4) > l {
            return io.ErrUnexpectedEOF
         }
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.Confidence = float32(math.Float32frombits(v))
      default:
         iNdEx = preIndex
         skippy, err := 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 *ThftResult) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 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: ThftResult: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ThftResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Gender", wireType)
         }
         m.Gender = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Gender |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
         }
         m.Age = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Age |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Race", wireType)
         }
         m.Race = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Race |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Beauty", wireType)
         }
         m.Beauty = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Beauty |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Smile", wireType)
         }
         m.Smile = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Smile |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := 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 *FacePos) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 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: FacePos: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: FacePos: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcFace", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.RcFace == nil {
            m.RcFace = &Rect{}
         }
         if err := m.RcFace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtLeftEye", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtLeftEye == nil {
            m.PtLeftEye = &Point{}
         }
         if err := m.PtLeftEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtRightEye", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtRightEye == nil {
            m.PtRightEye = &Point{}
         }
         if err := m.PtRightEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtMouth", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtMouth == nil {
            m.PtMouth = &Point{}
         }
         if err := m.PtMouth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtNose", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtNose == nil {
            m.PtNose = &Point{}
         }
         if err := m.PtNose.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field FAngle", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.FAngle == nil {
            m.FAngle = &FaceAngle{}
         }
         if err := m.FAngle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Quality", wireType)
         }
         m.Quality = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Quality |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field FacialData", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
         if m.FacialData == nil {
            m.FacialData = []byte{}
         }
         iNdEx = postIndex
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceID", wireType)
         }
         m.FaceID = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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:])
         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 *FaceInfo) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 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: FaceInfo: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: FaceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcFace", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.RcFace == nil {
            m.RcFace = &Rect{}
         }
         if err := m.RcFace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtLeftEye", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtLeftEye == nil {
            m.PtLeftEye = &Point{}
         }
         if err := m.PtLeftEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtRightEye", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtRightEye == nil {
            m.PtRightEye = &Point{}
         }
         if err := m.PtRightEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtMouth", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtMouth == nil {
            m.PtMouth = &Point{}
         }
         if err := m.PtMouth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PtNose", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.PtNose == nil {
            m.PtNose = &Point{}
         }
         if err := m.PtNose.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field FAngle", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.FAngle == nil {
            m.FAngle = &FaceAngle{}
         }
         if err := m.FAngle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Quality", wireType)
         }
         m.Quality = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Quality |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field FacialData", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
         if m.FacialData == nil {
            m.FacialData = []byte{}
         }
         iNdEx = postIndex
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceID", wireType)
         }
         m.FaceID = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FaceID |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := 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 *ObjInfo) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 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: ObjInfo: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ObjInfo: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcObj", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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.RcObj == nil {
            m.RcObj = &Rect{}
         }
         if err := m.RcObj.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
         }
         m.Typ = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Typ |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field Prob", wireType)
         }
         var v uint32
         if (iNdEx + 4) > l {
            return io.ErrUnexpectedEOF
         }
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.Prob = float32(math.Float32frombits(v))
      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:])
         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 *ResultFaceDetect) 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: ResultFaceDetect: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ResultFaceDetect: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Pos == nil {
            m.Pos = &FacePos{}
         }
         if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         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
         }
         if m.Result == nil {
            m.Result = &ThftResult{}
         }
         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:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *ParamYoloObj) 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: ParamYoloObj: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ParamYoloObj: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Infos", 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.Infos = append(m.Infos, &ObjInfo{})
         if err := m.Infos[len(m.Infos)-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 *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
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 0, ErrIntOverflowSdk
         }
         if iNdEx >= l {
            return 0, io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= (uint64(b) & 0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      wireType := int(wire & 0x7)
      switch wireType {
      case 0:
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            iNdEx++
            if dAtA[iNdEx-1] < 0x80 {
               break
            }
         }
         return iNdEx, nil
      case 1:
         iNdEx += 8
         return iNdEx, nil
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            length |= (int(b) & 0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if length < 0 {
            return 0, ErrInvalidLengthSdk
         }
         iNdEx += length
         if iNdEx < 0 {
            return 0, ErrInvalidLengthSdk
         }
         return iNdEx, nil
      case 3:
         for {
            var innerWire uint64
            var start int = iNdEx
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return 0, ErrIntOverflowSdk
               }
               if iNdEx >= l {
                  return 0, io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               innerWire |= (uint64(b) & 0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            innerWireType := int(innerWire & 0x7)
            if innerWireType == 4 {
               break
            }
            next, err := skipSdk(dAtA[start:])
            if err != nil {
               return 0, err
            }
            iNdEx = start + next
            if iNdEx < 0 {
               return 0, ErrInvalidLengthSdk
            }
         }
         return iNdEx, nil
      case 4:
         return iNdEx, nil
      case 5:
         iNdEx += 4
         return iNdEx, nil
      default:
         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
   }
   panic("unreachable")
}

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