Merge branch 'master' of ssh://192.168.5.5:29418/pubsub/protomsg

zhangmeng

2019-11-21 a22263550e9ee3e8c6f70ba5d66580a2e1e07798

 sdk.pb.go

@@ -861,14 +861,15 @@
   RcLocation          *Rect  `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   NTime               int32  `protobuf:"varint,9,opt,name=nTime,proto3" json:"nTime,omitempty"`
   NCarBright          int32  `protobuf:"varint,10,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
   NCarLogo            int32  `protobuf:"varint,11,opt,name=nCarLogo,proto3" json:"nCarLogo,omitempty"`
   NCarType            int32  `protobuf:"varint,12,opt,name=nCarType,proto3" json:"nCarType,omitempty"`
   PlateBin            []byte `protobuf:"bytes,13,opt,name=plateBin,proto3" json:"plateBin,omitempty"`
   NBinPlateWidth      []byte `protobuf:"bytes,14,opt,name=nBinPlateWidth,proto3" json:"nBinPlateWidth,omitempty"`
   NBinPlateHeight     []byte `protobuf:"bytes,15,opt,name=nBinPlateHeight,proto3" json:"nBinPlateHeight,omitempty"`
   RcLogoLocation      *Rect  `protobuf:"bytes,16,opt,name=rcLogoLocation,proto3" json:"rcLogoLocation,omitempty"`
   NCarModel           []byte `protobuf:"bytes,17,opt,name=nCarModel,proto3" json:"nCarModel,omitempty"`
   NCarModelConfidence []byte `protobuf:"bytes,18,opt,name=nCarModelConfidence,proto3" json:"nCarModelConfidence,omitempty"`
   NCarColor           int32  `protobuf:"varint,11,opt,name=NCarColor,proto3" json:"NCarColor,omitempty"`
   NCarLogo            int32  `protobuf:"varint,12,opt,name=nCarLogo,proto3" json:"nCarLogo,omitempty"`
   NCarType            int32  `protobuf:"varint,13,opt,name=nCarType,proto3" json:"nCarType,omitempty"`
   PlateBin            []byte `protobuf:"bytes,14,opt,name=plateBin,proto3" json:"plateBin,omitempty"`
   NBinPlateWidth      []byte `protobuf:"bytes,15,opt,name=nBinPlateWidth,proto3" json:"nBinPlateWidth,omitempty"`
   NBinPlateHeight     []byte `protobuf:"bytes,16,opt,name=nBinPlateHeight,proto3" json:"nBinPlateHeight,omitempty"`
   RcLogoLocation      *Rect  `protobuf:"bytes,17,opt,name=rcLogoLocation,proto3" json:"rcLogoLocation,omitempty"`
   NCarModel           []byte `protobuf:"bytes,18,opt,name=nCarModel,proto3" json:"nCarModel,omitempty"`
   NCarModelConfidence []byte `protobuf:"bytes,19,opt,name=nCarModelConfidence,proto3" json:"nCarModelConfidence,omitempty"`
}

func (m *PlateID) Reset()         { *m = PlateID{} }
@@ -974,6 +975,13 @@
   return 0
}

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

func (m *PlateID) GetNCarLogo() int32 {
   if m != nil {
      return m.NCarLogo
@@ -1074,6 +1082,423 @@
   return nil
}

// cloud
type PlateCloudID struct {
   License      string `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
   RcLocation   *Rect  `protobuf:"bytes,2,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   NConfidence  int32  `protobuf:"varint,3,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NType        int32  `protobuf:"varint,4,opt,name=nType,proto3" json:"nType,omitempty"`
   NDirection   int32  `protobuf:"varint,5,opt,name=nDirection,proto3" json:"nDirection,omitempty"`
   NCarColor    int32  `protobuf:"varint,6,opt,name=nCarColor,proto3" json:"nCarColor,omitempty"`
   NCarColor1   int32  `protobuf:"varint,7,opt,name=nCarColor1,proto3" json:"nCarColor1,omitempty"`
   NCarBright   int32  `protobuf:"varint,8,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
   FrameNo      int32  `protobuf:"varint,9,opt,name=frameNo,proto3" json:"frameNo,omitempty"`
   FaceWidth    int32  `protobuf:"varint,10,opt,name=faceWidth,proto3" json:"faceWidth,omitempty"`
   FaceHeight   int32  `protobuf:"varint,11,opt,name=faceHeight,proto3" json:"faceHeight,omitempty"`
   GrayFaceFlag int32  `protobuf:"varint,12,opt,name=grayFaceFlag,proto3" json:"grayFaceFlag,omitempty"`
   CharNum      int32  `protobuf:"varint,13,opt,name=charNum,proto3" json:"charNum,omitempty"`
}

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

var xxx_messageInfo_PlateCloudID proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var xxx_messageInfo_PlateCloudIDResult proto.InternalMessageInfo

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

type PlateVehicleID struct {
   NPlateFlag       int32   `protobuf:"varint,1,opt,name=nPlateFlag,proto3" json:"nPlateFlag,omitempty"`
   NColor           int32   `protobuf:"varint,2,opt,name=nColor,proto3" json:"nColor,omitempty"`
   NType            int32   `protobuf:"varint,3,opt,name=nType,proto3" json:"nType,omitempty"`
   License          string  `protobuf:"bytes,4,opt,name=license,proto3" json:"license,omitempty"`
   NConfidence      int32   `protobuf:"varint,5,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NCharNum         int32   `protobuf:"varint,6,opt,name=nCharNum,proto3" json:"nCharNum,omitempty"`
   NCharConfidence  []byte  `protobuf:"bytes,7,opt,name=nCharConfidence,proto3" json:"nCharConfidence,omitempty"`
   RcLocation       *Rect   `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   RcCarLocation    *Rect   `protobuf:"bytes,9,opt,name=rcCarLocation,proto3" json:"rcCarLocation,omitempty"`
   VehicleType      string  `protobuf:"bytes,10,opt,name=vehicleType,proto3" json:"vehicleType,omitempty"`
   VehicleBrand     string  `protobuf:"bytes,11,opt,name=vehicleBrand,proto3" json:"vehicleBrand,omitempty"`
   VehicleSub       string  `protobuf:"bytes,12,opt,name=vehicleSub,proto3" json:"vehicleSub,omitempty"`
   VehicleType1     string  `protobuf:"bytes,13,opt,name=vehicleType1,proto3" json:"vehicleType1,omitempty"`
   FvdConf          float32 `protobuf:"fixed32,14,opt,name=fvdConf,proto3" json:"fvdConf,omitempty"`
   FConfdence       float32 `protobuf:"fixed32,15,opt,name=fConfdence,proto3" json:"fConfdence,omitempty"`
   NVehicleSubModel int32   `protobuf:"varint,16,opt,name=nVehicleSubModel,proto3" json:"nVehicleSubModel,omitempty"`
   NVehicleBright   int32   `protobuf:"varint,17,opt,name=nVehicleBright,proto3" json:"nVehicleBright,omitempty"`
   NVehicleColor1   int32   `protobuf:"varint,18,opt,name=nVehicleColor1,proto3" json:"nVehicleColor1,omitempty"`
   NVehicleColor2   int32   `protobuf:"varint,19,opt,name=nVehicleColor2,proto3" json:"nVehicleColor2,omitempty"`
}

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

var xxx_messageInfo_PlateVehicleID proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var xxx_messageInfo_PlateVehicleIDResult proto.InternalMessageInfo

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

func init() {
   proto.RegisterType((*Image)(nil), "protomsg.Image")
   proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
@@ -1089,74 +1514,100 @@
   proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
   proto.RegisterType((*PlateID)(nil), "protomsg.PlateID")
   proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
   proto.RegisterType((*PlateCloudID)(nil), "protomsg.PlateCloudID")
   proto.RegisterType((*PlateCloudIDResult)(nil), "protomsg.PlateCloudIDResult")
   proto.RegisterType((*PlateVehicleID)(nil), "protomsg.PlateVehicleID")
   proto.RegisterType((*PlateVehicleIDResult)(nil), "protomsg.PlateVehicleIDResult")
}

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

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -1806,36 +2257,43 @@
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
   }
   if m.NCarLogo != 0 {
   if m.NCarColor != 0 {
      dAtA[i] = 0x58
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor))
   }
   if m.NCarLogo != 0 {
      dAtA[i] = 0x60
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarLogo))
   }
   if m.NCarType != 0 {
      dAtA[i] = 0x60
      dAtA[i] = 0x68
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarType))
   }
   if len(m.PlateBin) > 0 {
      dAtA[i] = 0x6a
      dAtA[i] = 0x72
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.PlateBin)))
      i += copy(dAtA[i:], m.PlateBin)
   }
   if len(m.NBinPlateWidth) > 0 {
      dAtA[i] = 0x72
      dAtA[i] = 0x7a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateWidth)))
      i += copy(dAtA[i:], m.NBinPlateWidth)
   }
   if len(m.NBinPlateHeight) > 0 {
      dAtA[i] = 0x7a
      dAtA[i] = 0x82
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateHeight)))
      i += copy(dAtA[i:], m.NBinPlateHeight)
   }
   if m.RcLogoLocation != nil {
      dAtA[i] = 0x82
      dAtA[i] = 0x8a
      i++
      dAtA[i] = 0x1
      i++
@@ -1847,7 +2305,7 @@
      i += n18
   }
   if len(m.NCarModel) > 0 {
      dAtA[i] = 0x8a
      dAtA[i] = 0x92
      i++
      dAtA[i] = 0x1
      i++
@@ -1855,7 +2313,7 @@
      i += copy(dAtA[i:], m.NCarModel)
   }
   if len(m.NCarModelConfidence) > 0 {
      dAtA[i] = 0x92
      dAtA[i] = 0x9a
      i++
      dAtA[i] = 0x1
      i++
@@ -1876,6 +2334,294 @@
}

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

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

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

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

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

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

func (m *PlateVehicleID) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.NPlateFlag != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NPlateFlag))
   }
   if m.NColor != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
   }
   if m.NType != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NType))
   }
   if len(m.License) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
      i += copy(dAtA[i:], m.License)
   }
   if m.NConfidence != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
   }
   if m.NCharNum != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCharNum))
   }
   if len(m.NCharConfidence) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NCharConfidence)))
      i += copy(dAtA[i:], m.NCharConfidence)
   }
   if m.RcLocation != nil {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
      n20, err20 := m.RcLocation.MarshalTo(dAtA[i:])
      if err20 != nil {
         return 0, err20
      }
      i += n20
   }
   if m.RcCarLocation != nil {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcCarLocation.Size()))
      n21, err21 := m.RcCarLocation.MarshalTo(dAtA[i:])
      if err21 != nil {
         return 0, err21
      }
      i += n21
   }
   if len(m.VehicleType) > 0 {
      dAtA[i] = 0x52
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType)))
      i += copy(dAtA[i:], m.VehicleType)
   }
   if len(m.VehicleBrand) > 0 {
      dAtA[i] = 0x5a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleBrand)))
      i += copy(dAtA[i:], m.VehicleBrand)
   }
   if len(m.VehicleSub) > 0 {
      dAtA[i] = 0x62
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleSub)))
      i += copy(dAtA[i:], m.VehicleSub)
   }
   if len(m.VehicleType1) > 0 {
      dAtA[i] = 0x6a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType1)))
      i += copy(dAtA[i:], m.VehicleType1)
   }
   if m.FvdConf != 0 {
      dAtA[i] = 0x75
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FvdConf))))
      i += 4
   }
   if m.FConfdence != 0 {
      dAtA[i] = 0x7d
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FConfdence))))
      i += 4
   }
   if m.NVehicleSubModel != 0 {
      dAtA[i] = 0x80
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleSubModel))
   }
   if m.NVehicleBright != 0 {
      dAtA[i] = 0x88
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleBright))
   }
   if m.NVehicleColor1 != 0 {
      dAtA[i] = 0x90
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor1))
   }
   if m.NVehicleColor2 != 0 {
      dAtA[i] = 0x98
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor2))
   }
   return i, nil
}

func (m *PlateVehicleIDResult) 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 *PlateVehicleIDResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2234,6 +2980,9 @@
   if m.NCarBright != 0 {
      n += 1 + sovSdk(uint64(m.NCarBright))
   }
   if m.NCarColor != 0 {
      n += 1 + sovSdk(uint64(m.NCarColor))
   }
   if m.NCarLogo != 0 {
      n += 1 + sovSdk(uint64(m.NCarLogo))
   }
@@ -2250,7 +2999,7 @@
   }
   l = len(m.NBinPlateHeight)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
      n += 2 + l + sovSdk(uint64(l))
   }
   if m.RcLogoLocation != nil {
      l = m.RcLogoLocation.Size()
@@ -2268,6 +3017,160 @@
}

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

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

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

func (m *PlateVehicleID) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.NPlateFlag != 0 {
      n += 1 + sovSdk(uint64(m.NPlateFlag))
   }
   if m.NColor != 0 {
      n += 1 + sovSdk(uint64(m.NColor))
   }
   if m.NType != 0 {
      n += 1 + sovSdk(uint64(m.NType))
   }
   l = len(m.License)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   if m.NConfidence != 0 {
      n += 1 + sovSdk(uint64(m.NConfidence))
   }
   if m.NCharNum != 0 {
      n += 1 + sovSdk(uint64(m.NCharNum))
   }
   l = len(m.NCharConfidence)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   if m.RcLocation != nil {
      l = m.RcLocation.Size()
      n += 1 + l + sovSdk(uint64(l))
   }
   if m.RcCarLocation != nil {
      l = m.RcCarLocation.Size()
      n += 1 + l + sovSdk(uint64(l))
   }
   l = len(m.VehicleType)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   l = len(m.VehicleBrand)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   l = len(m.VehicleSub)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   l = len(m.VehicleType1)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
   }
   if m.FvdConf != 0 {
      n += 5
   }
   if m.FConfdence != 0 {
      n += 5
   }
   if m.NVehicleSubModel != 0 {
      n += 2 + sovSdk(uint64(m.NVehicleSubModel))
   }
   if m.NVehicleBright != 0 {
      n += 2 + sovSdk(uint64(m.NVehicleBright))
   }
   if m.NVehicleColor1 != 0 {
      n += 2 + sovSdk(uint64(m.NVehicleColor1))
   }
   if m.NVehicleColor2 != 0 {
      n += 2 + sovSdk(uint64(m.NVehicleColor2))
   }
   return n
}

func (m *PlateVehicleIDResult) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -4582,6 +5485,25 @@
         }
      case 11:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarColor", wireType)
         }
         m.NCarColor = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarColor |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 12:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarLogo", wireType)
         }
         m.NCarLogo = 0
@@ -4599,7 +5521,7 @@
               break
            }
         }
      case 12:
      case 13:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarType", wireType)
         }
@@ -4618,7 +5540,7 @@
               break
            }
         }
      case 13:
      case 14:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PlateBin", wireType)
         }
@@ -4652,7 +5574,7 @@
            m.PlateBin = []byte{}
         }
         iNdEx = postIndex
      case 14:
      case 15:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NBinPlateWidth", wireType)
         }
@@ -4686,7 +5608,7 @@
            m.NBinPlateWidth = []byte{}
         }
         iNdEx = postIndex
      case 15:
      case 16:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NBinPlateHeight", wireType)
         }
@@ -4720,7 +5642,7 @@
            m.NBinPlateHeight = []byte{}
         }
         iNdEx = postIndex
      case 16:
      case 17:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcLogoLocation", wireType)
         }
@@ -4756,7 +5678,7 @@
            return err
         }
         iNdEx = postIndex
      case 17:
      case 18:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarModel", wireType)
         }
@@ -4790,7 +5712,7 @@
            m.NCarModel = []byte{}
         }
         iNdEx = postIndex
      case 18:
      case 19:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarModelConfidence", wireType)
         }
@@ -4935,6 +5857,1022 @@
   }
   return nil
}
func (m *PlateCloudID) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowSdk
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateCloudID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudID: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.License = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcLocation", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.RcLocation == nil {
            m.RcLocation = &Rect{}
         }
         if err := m.RcLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NConfidence", wireType)
         }
         m.NConfidence = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NConfidence |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NType", wireType)
         }
         m.NType = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NType |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NDirection", wireType)
         }
         m.NDirection = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NDirection |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarColor", wireType)
         }
         m.NCarColor = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarColor |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarColor1", wireType)
         }
         m.NCarColor1 = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarColor1 |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 8:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarBright", wireType)
         }
         m.NCarBright = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarBright |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FrameNo", wireType)
         }
         m.FrameNo = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FrameNo |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 10:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceWidth", wireType)
         }
         m.FaceWidth = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FaceWidth |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 11:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceHeight", wireType)
         }
         m.FaceHeight = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FaceHeight |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 12:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field GrayFaceFlag", wireType)
         }
         m.GrayFaceFlag = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.GrayFaceFlag |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 13:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field CharNum", wireType)
         }
         m.CharNum = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.CharNum |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *PlateVehicleID) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowSdk
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: PlateVehicleID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateVehicleID: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NPlateFlag", wireType)
         }
         m.NPlateFlag = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NPlateFlag |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NColor", wireType)
         }
         m.NColor = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NColor |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NType", wireType)
         }
         m.NType = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NType |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.License = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NConfidence", wireType)
         }
         m.NConfidence = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NConfidence |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCharNum", wireType)
         }
         m.NCharNum = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCharNum |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCharConfidence", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.NCharConfidence = append(m.NCharConfidence[:0], dAtA[iNdEx:postIndex]...)
         if m.NCharConfidence == nil {
            m.NCharConfidence = []byte{}
         }
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcLocation", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.RcLocation == nil {
            m.RcLocation = &Rect{}
         }
         if err := m.RcLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 9:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcCarLocation", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.RcCarLocation == nil {
            m.RcCarLocation = &Rect{}
         }
         if err := m.RcCarLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 10:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VehicleType", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.VehicleType = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 11:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VehicleBrand", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.VehicleBrand = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 12:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VehicleSub", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.VehicleSub = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 13:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VehicleType1", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSdk
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSdk
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.VehicleType1 = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 14:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field FvdConf", wireType)
         }
         var v uint32
         if (iNdEx + 4) > l {
            return io.ErrUnexpectedEOF
         }
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.FvdConf = float32(math.Float32frombits(v))
      case 15:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field FConfdence", wireType)
         }
         var v uint32
         if (iNdEx + 4) > l {
            return io.ErrUnexpectedEOF
         }
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.FConfdence = float32(math.Float32frombits(v))
      case 16:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NVehicleSubModel", wireType)
         }
         m.NVehicleSubModel = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NVehicleSubModel |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 17:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NVehicleBright", wireType)
         }
         m.NVehicleBright = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NVehicleBright |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 18:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NVehicleColor1", wireType)
         }
         m.NVehicleColor1 = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NVehicleColor1 |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 19:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NVehicleColor2", wireType)
         }
         m.NVehicleColor2 = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NVehicleColor2 |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSdk(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSdk
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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

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