add

zhangmeng

2019-06-17 724955ab9975697a81f260dc4838ea5cee462176

add

 base.pb.go

File was deleted

 base.proto

File was deleted

 protomsg.pb.go

@@ -2396,6 +2396,767 @@
    return 0
}

// struct for sdk
type Point struct {
    X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
    Y int32 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
}

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

var xxx_messageInfo_Point proto.InternalMessageInfo

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

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

type Rect struct {
    Left   int32 `protobuf:"varint,1,opt,name=left,proto3" json:"left,omitempty"`
    Top    int32 `protobuf:"varint,2,opt,name=top,proto3" json:"top,omitempty"`
    Right  int32 `protobuf:"varint,3,opt,name=right,proto3" json:"right,omitempty"`
    Bottom int32 `protobuf:"varint,4,opt,name=bottom,proto3" json:"bottom,omitempty"`
}

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

var xxx_messageInfo_Rect proto.InternalMessageInfo

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

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

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

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

// 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"`
}

func (m *Image) Reset()         { *m = Image{} }
func (m *Image) String() string { return proto.CompactTextString(m) }
func (*Image) ProtoMessage()    {}
func (*Image) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{25}
}
func (m *Image) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *Image) XXX_DiscardUnknown() {
    xxx_messageInfo_Image.DiscardUnknown(m)
}

var xxx_messageInfo_Image proto.InternalMessageInfo

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

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

func (m *Image) GetData() []byte {
    if m != nil {
        return m.Data
    }
    return nil
}

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

func (m *FaceAngle) Reset()         { *m = FaceAngle{} }
func (m *FaceAngle) String() string { return proto.CompactTextString(m) }
func (*FaceAngle) ProtoMessage()    {}
func (*FaceAngle) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{26}
}
func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *FaceAngle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *FaceAngle) XXX_DiscardUnknown() {
    xxx_messageInfo_FaceAngle.DiscardUnknown(m)
}

var xxx_messageInfo_FaceAngle proto.InternalMessageInfo

func (m *FaceAngle) GetYaw() int32 {
    if m != nil {
        return m.Yaw
    }
    return 0
}

func (m *FaceAngle) GetPitch() int32 {
    if m != nil {
        return m.Pitch
    }
    return 0
}

func (m *FaceAngle) GetRoll() int32 {
    if m != nil {
        return m.Roll
    }
    return 0
}

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

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"`
}

func (m *ThftResult) Reset()         { *m = ThftResult{} }
func (m *ThftResult) String() string { return proto.CompactTextString(m) }
func (*ThftResult) ProtoMessage()    {}
func (*ThftResult) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{27}
}
func (m *ThftResult) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ThftResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *ThftResult) XXX_DiscardUnknown() {
    xxx_messageInfo_ThftResult.DiscardUnknown(m)
}

var xxx_messageInfo_ThftResult proto.InternalMessageInfo

func (m *ThftResult) GetGender() int32 {
    if m != nil {
        return m.Gender
    }
    return 0
}

func (m *ThftResult) GetAge() int32 {
    if m != nil {
        return m.Age
    }
    return 0
}

func (m *ThftResult) GetRace() int32 {
    if m != nil {
        return m.Race
    }
    return 0
}

func (m *ThftResult) GetBeauty() int32 {
    if m != nil {
        return m.Beauty
    }
    return 0
}

func (m *ThftResult) GetSmile() int32 {
    if m != nil {
        return m.Smile
    }
    return 0
}

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"`
}

func (m *FacePos) Reset()         { *m = FacePos{} }
func (m *FacePos) String() string { return proto.CompactTextString(m) }
func (*FacePos) ProtoMessage()    {}
func (*FacePos) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{28}
}
func (m *FacePos) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *FacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *FacePos) XXX_DiscardUnknown() {
    xxx_messageInfo_FacePos.DiscardUnknown(m)
}

var xxx_messageInfo_FacePos proto.InternalMessageInfo

func (m *FacePos) GetRcFace() *Rect {
    if m != nil {
        return m.RcFace
    }
    return nil
}

func (m *FacePos) GetPtLeftEye() *Point {
    if m != nil {
        return m.PtLeftEye
    }
    return nil
}

func (m *FacePos) GetPtRightEye() *Point {
    if m != nil {
        return m.PtRightEye
    }
    return nil
}

func (m *FacePos) GetPtMouth() *Point {
    if m != nil {
        return m.PtMouth
    }
    return nil
}

func (m *FacePos) GetPtNose() *Point {
    if m != nil {
        return m.PtNose
    }
    return nil
}

func (m *FacePos) GetFAngle() *FaceAngle {
    if m != nil {
        return m.FAngle
    }
    return nil
}

func (m *FacePos) GetQuality() int32 {
    if m != nil {
        return m.Quality
    }
    return 0
}

func (m *FacePos) GetFacialData() []byte {
    if m != nil {
        return m.FacialData
    }
    return nil
}

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"`
}

func (m *FaceInfo) Reset()         { *m = FaceInfo{} }
func (m *FaceInfo) String() string { return proto.CompactTextString(m) }
func (*FaceInfo) ProtoMessage()    {}
func (*FaceInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{29}
}
func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *FaceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *FaceInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_FaceInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FaceInfo proto.InternalMessageInfo

func (m *FaceInfo) GetRcFace() *Rect {
    if m != nil {
        return m.RcFace
    }
    return nil
}

func (m *FaceInfo) GetPtLeftEye() *Point {
    if m != nil {
        return m.PtLeftEye
    }
    return nil
}

func (m *FaceInfo) GetPtRightEye() *Point {
    if m != nil {
        return m.PtRightEye
    }
    return nil
}

func (m *FaceInfo) GetPtMouth() *Point {
    if m != nil {
        return m.PtMouth
    }
    return nil
}

func (m *FaceInfo) GetPtNose() *Point {
    if m != nil {
        return m.PtNose
    }
    return nil
}

func (m *FaceInfo) GetFAngle() *FaceAngle {
    if m != nil {
        return m.FAngle
    }
    return nil
}

func (m *FaceInfo) GetQuality() int32 {
    if m != nil {
        return m.Quality
    }
    return 0
}

func (m *FaceInfo) GetFacialData() []byte {
    if m != nil {
        return m.FacialData
    }
    return nil
}

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

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"`
}

func (m *ObjInfo) Reset()         { *m = ObjInfo{} }
func (m *ObjInfo) String() string { return proto.CompactTextString(m) }
func (*ObjInfo) ProtoMessage()    {}
func (*ObjInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{30}
}
func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ObjInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *ObjInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_ObjInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ObjInfo proto.InternalMessageInfo

func (m *ObjInfo) GetRcObj() *Rect {
    if m != nil {
        return m.RcObj
    }
    return nil
}

func (m *ObjInfo) GetTyp() int32 {
    if m != nil {
        return m.Typ
    }
    return 0
}

func (m *ObjInfo) GetProb() float32 {
    if m != nil {
        return m.Prob
    }
    return 0
}

// sdk face property
type ParamFacePos struct {
    Pos    *FacePos    `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
    Result *ThftResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
    Img    *Image      `protobuf:"bytes,3,opt,name=img,proto3" json:"img,omitempty"`
}

func (m *ParamFacePos) Reset()         { *m = ParamFacePos{} }
func (m *ParamFacePos) String() string { return proto.CompactTextString(m) }
func (*ParamFacePos) ProtoMessage()    {}
func (*ParamFacePos) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{31}
}
func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ParamFacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *ParamFacePos) XXX_DiscardUnknown() {
    xxx_messageInfo_ParamFacePos.DiscardUnknown(m)
}

var xxx_messageInfo_ParamFacePos proto.InternalMessageInfo

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

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

func (m *ParamFacePos) GetImg() *Image {
    if m != nil {
        return m.Img
    }
    return nil
}

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

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

var xxx_messageInfo_ParamFaceCompare proto.InternalMessageInfo

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

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

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

func (m *ParamYoloObj) Reset()         { *m = ParamYoloObj{} }
func (m *ParamYoloObj) String() string { return proto.CompactTextString(m) }
func (*ParamYoloObj) ProtoMessage()    {}
func (*ParamYoloObj) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{33}
}
func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ParamYoloObj) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    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 m.Size()
}
func (m *ParamYoloObj) XXX_DiscardUnknown() {
    xxx_messageInfo_ParamYoloObj.DiscardUnknown(m)
}

var xxx_messageInfo_ParamYoloObj proto.InternalMessageInfo

func (m *ParamYoloObj) GetInfos() []*ObjInfo {
    if m != nil {
        return m.Infos
    }
    return nil
}

func (m *ParamYoloObj) GetImg() *Image {
    if m != nil {
        return m.Img
    }
    return nil
}

func init() {
    proto.RegisterEnum("protomsg.TableChanged", TableChanged_name, TableChanged_value)
    proto.RegisterEnum("protomsg.DbAction", DbAction_name, DbAction_value)
@@ -2422,150 +3183,192 @@
    proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
    proto.RegisterType((*DbChangeMessage)(nil), "protomsg.DbChangeMessage")
    proto.RegisterType((*CameraPolygon)(nil), "protomsg.CameraPolygon")
    proto.RegisterType((*Point)(nil), "protomsg.Point")
    proto.RegisterType((*Rect)(nil), "protomsg.Rect")
    proto.RegisterType((*Image)(nil), "protomsg.Image")
    proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
    proto.RegisterType((*ThftResult)(nil), "protomsg.ThftResult")
    proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
    proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
    proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
    proto.RegisterType((*ParamFacePos)(nil), "protomsg.ParamFacePos")
    proto.RegisterType((*ParamFaceCompare)(nil), "protomsg.ParamFaceCompare")
    proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
}

func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

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

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
@@ -4297,6 +5100,528 @@
    return i, nil
}

func (m *Point) 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 *Point) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.X != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.X))
    }
    if m.Y != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Y))
    }
    return i, nil
}

func (m *Rect) 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 *Rect) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Left != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Left))
    }
    if m.Top != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Top))
    }
    if m.Right != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Right))
    }
    if m.Bottom != 0 {
        dAtA[i] = 0x20
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Bottom))
    }
    return i, nil
}

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 = encodeVarintProtomsg(dAtA, i, uint64(m.Width))
    }
    if m.Height != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Height))
    }
    if len(m.Data) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
        i += copy(dAtA[i:], m.Data)
    }
    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 = encodeVarintProtomsg(dAtA, i, uint64(m.Yaw))
    }
    if m.Pitch != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Pitch))
    }
    if m.Roll != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(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 = encodeVarintProtomsg(dAtA, i, uint64(m.Gender))
    }
    if m.Age != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Age))
    }
    if m.Race != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Race))
    }
    if m.Beauty != 0 {
        dAtA[i] = 0x20
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Beauty))
    }
    if m.Smile != 0 {
        dAtA[i] = 0x28
        i++
        i = encodeVarintProtomsg(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 = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
        n6, err6 := m.RcFace.MarshalTo(dAtA[i:])
        if err6 != nil {
            return 0, err6
        }
        i += n6
    }
    if m.PtLeftEye != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
        n7, err7 := m.PtLeftEye.MarshalTo(dAtA[i:])
        if err7 != nil {
            return 0, err7
        }
        i += n7
    }
    if m.PtRightEye != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
        n8, err8 := m.PtRightEye.MarshalTo(dAtA[i:])
        if err8 != nil {
            return 0, err8
        }
        i += n8
    }
    if m.PtMouth != nil {
        dAtA[i] = 0x22
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
        n9, err9 := m.PtMouth.MarshalTo(dAtA[i:])
        if err9 != nil {
            return 0, err9
        }
        i += n9
    }
    if m.PtNose != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
        n10, err10 := m.PtNose.MarshalTo(dAtA[i:])
        if err10 != nil {
            return 0, err10
        }
        i += n10
    }
    if m.FAngle != nil {
        dAtA[i] = 0x32
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
        n11, err11 := m.FAngle.MarshalTo(dAtA[i:])
        if err11 != nil {
            return 0, err11
        }
        i += n11
    }
    if m.Quality != 0 {
        dAtA[i] = 0x38
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Quality))
    }
    if len(m.FacialData) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FacialData)))
        i += copy(dAtA[i:], m.FacialData)
    }
    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 = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
        n12, err12 := m.RcFace.MarshalTo(dAtA[i:])
        if err12 != nil {
            return 0, err12
        }
        i += n12
    }
    if m.PtLeftEye != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
        n13, err13 := m.PtLeftEye.MarshalTo(dAtA[i:])
        if err13 != nil {
            return 0, err13
        }
        i += n13
    }
    if m.PtRightEye != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
        n14, err14 := m.PtRightEye.MarshalTo(dAtA[i:])
        if err14 != nil {
            return 0, err14
        }
        i += n14
    }
    if m.PtMouth != nil {
        dAtA[i] = 0x22
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
        n15, err15 := m.PtMouth.MarshalTo(dAtA[i:])
        if err15 != nil {
            return 0, err15
        }
        i += n15
    }
    if m.PtNose != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
        n16, err16 := m.PtNose.MarshalTo(dAtA[i:])
        if err16 != nil {
            return 0, err16
        }
        i += n16
    }
    if m.FAngle != nil {
        dAtA[i] = 0x32
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
        n17, err17 := m.FAngle.MarshalTo(dAtA[i:])
        if err17 != nil {
            return 0, err17
        }
        i += n17
    }
    if m.Quality != 0 {
        dAtA[i] = 0x38
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Quality))
    }
    if len(m.FacialData) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FacialData)))
        i += copy(dAtA[i:], m.FacialData)
    }
    if m.FaceID != 0 {
        dAtA[i] = 0x48
        i++
        i = encodeVarintProtomsg(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 = encodeVarintProtomsg(dAtA, i, uint64(m.RcObj.Size()))
        n18, err18 := m.RcObj.MarshalTo(dAtA[i:])
        if err18 != nil {
            return 0, err18
        }
        i += n18
    }
    if m.Typ != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(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
    }
    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 m.Pos != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Pos.Size()))
        n19, err19 := m.Pos.MarshalTo(dAtA[i:])
        if err19 != nil {
            return 0, err19
        }
        i += n19
    }
    if m.Result != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Result.Size()))
        n20, err20 := m.Result.MarshalTo(dAtA[i:])
        if err20 != nil {
            return 0, err20
        }
        i += n20
    }
    if m.Img != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Img.Size()))
        n21, err21 := m.Img.MarshalTo(dAtA[i:])
        if err21 != nil {
            return 0, err21
        }
        i += n21
    }
    return i, nil
}

func (m *ParamFaceCompare) 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 *ParamFaceCompare) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Feat1) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat1)))
        i += copy(dAtA[i:], m.Feat1)
    }
    if len(m.Feat2) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat2)))
        i += copy(dAtA[i:], m.Feat2)
    }
    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 = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.Img != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Img.Size()))
        n22, err22 := m.Img.MarshalTo(dAtA[i:])
        if err22 != nil {
            return 0, err22
        }
        i += n22
    }
    return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -5246,6 +6571,265 @@
    }
    if m.DefenceState != 0 {
        n += 1 + sovProtomsg(uint64(m.DefenceState))
    }
    return n
}

func (m *Point) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.X != 0 {
        n += 1 + sovProtomsg(uint64(m.X))
    }
    if m.Y != 0 {
        n += 1 + sovProtomsg(uint64(m.Y))
    }
    return n
}

func (m *Rect) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Left != 0 {
        n += 1 + sovProtomsg(uint64(m.Left))
    }
    if m.Top != 0 {
        n += 1 + sovProtomsg(uint64(m.Top))
    }
    if m.Right != 0 {
        n += 1 + sovProtomsg(uint64(m.Right))
    }
    if m.Bottom != 0 {
        n += 1 + sovProtomsg(uint64(m.Bottom))
    }
    return n
}

func (m *Image) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Width != 0 {
        n += 1 + sovProtomsg(uint64(m.Width))
    }
    if m.Height != 0 {
        n += 1 + sovProtomsg(uint64(m.Height))
    }
    l = len(m.Data)
    if l > 0 {
        n += 1 + l + sovProtomsg(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 + sovProtomsg(uint64(m.Yaw))
    }
    if m.Pitch != 0 {
        n += 1 + sovProtomsg(uint64(m.Pitch))
    }
    if m.Roll != 0 {
        n += 1 + sovProtomsg(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 + sovProtomsg(uint64(m.Gender))
    }
    if m.Age != 0 {
        n += 1 + sovProtomsg(uint64(m.Age))
    }
    if m.Race != 0 {
        n += 1 + sovProtomsg(uint64(m.Race))
    }
    if m.Beauty != 0 {
        n += 1 + sovProtomsg(uint64(m.Beauty))
    }
    if m.Smile != 0 {
        n += 1 + sovProtomsg(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 + sovProtomsg(uint64(l))
    }
    if m.PtLeftEye != nil {
        l = m.PtLeftEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtRightEye != nil {
        l = m.PtRightEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtMouth != nil {
        l = m.PtMouth.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtNose != nil {
        l = m.PtNose.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.FAngle != nil {
        l = m.FAngle.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Quality != 0 {
        n += 1 + sovProtomsg(uint64(m.Quality))
    }
    l = len(m.FacialData)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    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 + sovProtomsg(uint64(l))
    }
    if m.PtLeftEye != nil {
        l = m.PtLeftEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtRightEye != nil {
        l = m.PtRightEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtMouth != nil {
        l = m.PtMouth.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtNose != nil {
        l = m.PtNose.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.FAngle != nil {
        l = m.FAngle.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Quality != 0 {
        n += 1 + sovProtomsg(uint64(m.Quality))
    }
    l = len(m.FacialData)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.FaceID != 0 {
        n += 1 + sovProtomsg(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 + sovProtomsg(uint64(l))
    }
    if m.Typ != 0 {
        n += 1 + sovProtomsg(uint64(m.Typ))
    }
    if m.Prob != 0 {
        n += 5
    }
    return n
}

func (m *ParamFacePos) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Pos != nil {
        l = m.Pos.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Result != nil {
        l = m.Result.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Img != nil {
        l = m.Img.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func (m *ParamFaceCompare) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Feat1)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.Feat2)
    if l > 0 {
        n += 1 + l + sovProtomsg(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 + sovProtomsg(uint64(l))
        }
    }
    if m.Img != nil {
        l = m.Img.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}
@@ -12048,6 +13632,1807 @@
    }
    return nil
}
func (m *Point) 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 ErrIntOverflowProtomsg
            }
            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: Point: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Point: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
            }
            m.X = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.X |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
            }
            m.Y = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Y |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *Rect) 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 ErrIntOverflowProtomsg
            }
            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: Rect: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Rect: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
            }
            m.Left = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Left |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Top", wireType)
            }
            m.Top = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Top |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
            }
            m.Right = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Right |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 4:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Bottom", wireType)
            }
            m.Bottom = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Bottom |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
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 ErrIntOverflowProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
            if m.Data == nil {
                m.Data = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                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 := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
            if m.FacialData == nil {
                m.FacialData = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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 := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                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))
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
            }
            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 Pos", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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 Img", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Img == nil {
                m.Img = &Image{}
            }
            if err := m.Img.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

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

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipProtomsg(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0

 protomsg.proto

@@ -1,5 +1,4 @@
syntax = "proto3";
import "base.proto";

package protomsg;

@@ -288,3 +287,80 @@
    string type = 7;
    int32 defence_state = 8;
}


// struct for sdk
message Point{
    int32 x = 1;
    int32 y = 2;
}
message Rect{
    int32 left = 1;
    int32 top = 2;
    int32 right = 3;
    int32 bottom = 4;
}
// Image ipc struct
message Image{
    int32 width = 1;
    int32 height = 2;
    bytes data = 3;
}

message FaceAngle{
    int32 yaw = 1;
    int32 pitch =2;
    int32 roll = 3;
    float confidence =4;
}
message ThftResult{
    int32 gender = 1;
    int32 age = 2;
    int32 race = 3;
    int32 beauty = 4;
    int32 smile = 5;
}
message FacePos{
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
}
message FaceInfo{
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
    int64 faceID = 9;
}
message ObjInfo{
    Rect rcObj = 1;
    int32 typ = 2;
    float prob = 3;
}

// sdk face property
message ParamFacePos{
    FacePos pos = 1;
    ThftResult result = 2;
    Image img = 3;
}
// sdk face extract
message ParamFaceCompare{
    bytes feat1 = 1;
    bytes feat2 = 2;
}

// sdk yolo detect
message ParamYoloObj{
    repeated ObjInfo infos = 1;
    Image img = 2;
}

 sdk.pb.go

File was deleted

 sdk.proto

File was deleted