update

zhangmeng

2019-06-16 8a2b616a4e38ba4af404937482368ad3f6392fb9

 protomsg.pb.go

@@ -22,6 +22,75 @@
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

//TableChanged enum
type TableChanged int32

const (
   TableChanged_T_Camera         TableChanged = 0
   TableChanged_T_CameraTask     TableChanged = 1
   TableChanged_T_CameraTaskArgs TableChanged = 2
   TableChanged_T_Task           TableChanged = 3
   TableChanged_T_TaskSdk        TableChanged = 4
   TableChanged_T_TaskSdkRule    TableChanged = 5
   TableChanged_T_Sdk            TableChanged = 6
)

var TableChanged_name = map[int32]string{
   0: "T_Camera",
   1: "T_CameraTask",
   2: "T_CameraTaskArgs",
   3: "T_Task",
   4: "T_TaskSdk",
   5: "T_TaskSdkRule",
   6: "T_Sdk",
}

var TableChanged_value = map[string]int32{
   "T_Camera":         0,
   "T_CameraTask":     1,
   "T_CameraTaskArgs": 2,
   "T_Task":           3,
   "T_TaskSdk":        4,
   "T_TaskSdkRule":    5,
   "T_Sdk":            6,
}

func (x TableChanged) String() string {
   return proto.EnumName(TableChanged_name, int32(x))
}

func (TableChanged) EnumDescriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{0}
}

type DbAction int32

const (
   DbAction_Insert DbAction = 0
   DbAction_Update DbAction = 1
   DbAction_Delete DbAction = 2
)

var DbAction_name = map[int32]string{
   0: "Insert",
   1: "Update",
   2: "Delete",
}

var DbAction_value = map[string]int32{
   "Insert": 0,
   "Update": 1,
   "Delete": 2,
}

func (x DbAction) String() string {
   return proto.EnumName(DbAction_name, int32(x))
}

func (DbAction) EnumDescriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{1}
}

type TaskLabel struct {
   Taskid string   `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
   Sdkids []string `protobuf:"bytes,2,rep,name=sdkids,proto3" json:"sdkids,omitempty"`
@@ -82,6 +151,7 @@
   return 0
}

//SdkMessage struct test
type SdkMessage struct {
   Cid     string     `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
   Tasklab *TaskLabel `protobuf:"bytes,2,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
@@ -413,6 +483,59 @@
   return ""
}

//摄像机的任务信息
type CameraAndTaskInfo struct {
   Camera *Camera `protobuf:"bytes,1,opt,name=camera,proto3" json:"camera,omitempty"`
   Tasks  []*Task `protobuf:"bytes,2,rep,name=tasks,proto3" json:"tasks,omitempty"`
}

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

var xxx_messageInfo_CameraAndTaskInfo proto.InternalMessageInfo

func (m *CameraAndTaskInfo) GetCamera() *Camera {
   if m != nil {
      return m.Camera
   }
   return nil
}

func (m *CameraAndTaskInfo) GetTasks() []*Task {
   if m != nil {
      return m.Tasks
   }
   return nil
}

//Task结构体
type Task struct {
   Taskid   string `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
@@ -429,7 +552,7 @@
func (m *Task) String() string { return proto.CompactTextString(m) }
func (*Task) ProtoMessage()    {}
func (*Task) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{5}
   return fileDescriptor_32de24555f916688, []int{6}
}
func (m *Task) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -523,7 +646,7 @@
func (m *TaskSdkInfo) String() string { return proto.CompactTextString(m) }
func (*TaskSdkInfo) ProtoMessage()    {}
func (*TaskSdkInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{6}
   return fileDescriptor_32de24555f916688, []int{7}
}
func (m *TaskSdkInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -586,7 +709,7 @@
func (m *CameraTask) String() string { return proto.CompactTextString(m) }
func (*CameraTask) ProtoMessage()    {}
func (*CameraTask) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{7}
   return fileDescriptor_32de24555f916688, []int{8}
}
func (m *CameraTask) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -699,6 +822,67 @@
   return ""
}

//摄像机布防的时间规则，可以设置多个,用id关联到具体的规则配置中
type CameraTimerule struct {
   Id       string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Name     string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   TimeRule string `protobuf:"bytes,3,opt,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
}

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

var xxx_messageInfo_CameraTimerule proto.InternalMessageInfo

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

func (m *CameraTimerule) GetName() string {
   if m != nil {
      return m.Name
   }
   return ""
}

func (m *CameraTimerule) GetTimeRule() string {
   if m != nil {
      return m.TimeRule
   }
   return ""
}

//DayCtl struct   每天的时间控制规则
type DayCtl struct {
   Day       int32        `protobuf:"varint,1,opt,name=day,proto3" json:"day,omitempty"`
@@ -709,7 +893,7 @@
func (m *DayCtl) String() string { return proto.CompactTextString(m) }
func (*DayCtl) ProtoMessage()    {}
func (*DayCtl) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{8}
   return fileDescriptor_32de24555f916688, []int{10}
}
func (m *DayCtl) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -762,7 +946,7 @@
func (m *TimeRange) String() string { return proto.CompactTextString(m) }
func (*TimeRange) ProtoMessage()    {}
func (*TimeRange) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{9}
   return fileDescriptor_32de24555f916688, []int{11}
}
func (m *TimeRange) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -809,14 +993,14 @@
type Polygon struct {
   Id     string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Name   string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   Points []*Point `protobuf:"bytes,4,rep,name=points,proto3" json:"points,omitempty"`
   Points []*Point `protobuf:"bytes,3,rep,name=points,proto3" json:"points,omitempty"`
}

func (m *Polygon) Reset()         { *m = Polygon{} }
func (m *Polygon) String() string { return proto.CompactTextString(m) }
func (*Polygon) ProtoMessage()    {}
func (*Polygon) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{10}
   return fileDescriptor_32de24555f916688, []int{12}
}
func (m *Polygon) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -867,25 +1051,15 @@
}

type CameraTaskArgs struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraTaskId string `protobuf:"bytes,2,opt,name=camera_task_id,json=cameraTaskId,proto3" json:"camera_task_id,omitempty"`
   CameraId     string `protobuf:"bytes,3,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   PolygonId    string `protobuf:"bytes,4,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
   SdkId        string `protobuf:"bytes,5,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
   SdkArgAlias  string `protobuf:"bytes,6,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator     string `protobuf:"bytes,7,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,8,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   SdkArgValue  string `protobuf:"bytes,9,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort         int32  `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
   RuleWithNext string `protobuf:"bytes,11,opt,name=rule_with_next,json=ruleWithNext,proto3" json:"rule_with_next,omitempty"`
   GroupId      string `protobuf:"bytes,12,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   CameraId string           `protobuf:"bytes,1,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   TaskArgs []*TaskGroupArgs `protobuf:"bytes,2,rep,name=task_args,json=taskArgs,proto3" json:"task_args,omitempty"`
}

func (m *CameraTaskArgs) Reset()         { *m = CameraTaskArgs{} }
func (m *CameraTaskArgs) String() string { return proto.CompactTextString(m) }
func (*CameraTaskArgs) ProtoMessage()    {}
func (*CameraTaskArgs) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{11}
   return fileDescriptor_32de24555f916688, []int{13}
}
func (m *CameraTaskArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -914,20 +1088,6 @@

var xxx_messageInfo_CameraTaskArgs proto.InternalMessageInfo

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

func (m *CameraTaskArgs) GetCameraTaskId() string {
   if m != nil {
      return m.CameraTaskId
   }
   return ""
}

func (m *CameraTaskArgs) GetCameraId() string {
   if m != nil {
      return m.CameraId
@@ -935,63 +1095,243 @@
   return ""
}

func (m *CameraTaskArgs) GetPolygonId() string {
func (m *CameraTaskArgs) GetTaskArgs() []*TaskGroupArgs {
   if m != nil {
      return m.TaskArgs
   }
   return nil
}

type TaskGroupArgs struct {
   TaskId     string       `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
   GroupRules []*GroupRule `protobuf:"bytes,2,rep,name=group_rules,json=groupRules,proto3" json:"group_rules,omitempty"`
}

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

var xxx_messageInfo_TaskGroupArgs proto.InternalMessageInfo

func (m *TaskGroupArgs) GetTaskId() string {
   if m != nil {
      return m.TaskId
   }
   return ""
}

func (m *TaskGroupArgs) GetGroupRules() []*GroupRule {
   if m != nil {
      return m.GroupRules
   }
   return nil
}

type GroupRule struct {
   GroupId string  `protobuf:"bytes,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   Rules   []*Rule `protobuf:"bytes,2,rep,name=rules,proto3" json:"rules,omitempty"`
}

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

var xxx_messageInfo_GroupRule proto.InternalMessageInfo

func (m *GroupRule) GetGroupId() string {
   if m != nil {
      return m.GroupId
   }
   return ""
}

func (m *GroupRule) GetRules() []*Rule {
   if m != nil {
      return m.Rules
   }
   return nil
}

type Rule struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraTaskId string `protobuf:"bytes,2,opt,name=camera_task_id,json=cameraTaskId,proto3" json:"camera_task_id,omitempty"`
   CameraId     string `protobuf:"bytes,3,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   PolygonId    string `protobuf:"bytes,4,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
   SdkId        string `protobuf:"bytes,5,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
   SdkArgAlias  string `protobuf:"bytes,6,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator     string `protobuf:"bytes,7,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,8,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   SdkArgValue  string `protobuf:"bytes,9,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort         int32  `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
   RuleWithPre  string `protobuf:"bytes,11,opt,name=rule_with_pre,json=ruleWithPre,proto3" json:"rule_with_pre,omitempty"`
   GroupId      string `protobuf:"bytes,12,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
}

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

var xxx_messageInfo_Rule proto.InternalMessageInfo

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

func (m *Rule) GetCameraTaskId() string {
   if m != nil {
      return m.CameraTaskId
   }
   return ""
}

func (m *Rule) GetCameraId() string {
   if m != nil {
      return m.CameraId
   }
   return ""
}

func (m *Rule) GetPolygonId() string {
   if m != nil {
      return m.PolygonId
   }
   return ""
}

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

func (m *CameraTaskArgs) GetSdkArgAlias() string {
func (m *Rule) GetSdkArgAlias() string {
   if m != nil {
      return m.SdkArgAlias
   }
   return ""
}

func (m *CameraTaskArgs) GetOperator() string {
func (m *Rule) GetOperator() string {
   if m != nil {
      return m.Operator
   }
   return ""
}

func (m *CameraTaskArgs) GetOperatorType() string {
func (m *Rule) GetOperatorType() string {
   if m != nil {
      return m.OperatorType
   }
   return ""
}

func (m *CameraTaskArgs) GetSdkArgValue() string {
func (m *Rule) GetSdkArgValue() string {
   if m != nil {
      return m.SdkArgValue
   }
   return ""
}

func (m *CameraTaskArgs) GetSort() int32 {
func (m *Rule) GetSort() int32 {
   if m != nil {
      return m.Sort
   }
   return 0
}

func (m *CameraTaskArgs) GetRuleWithNext() string {
func (m *Rule) GetRuleWithPre() string {
   if m != nil {
      return m.RuleWithNext
      return m.RuleWithPre
   }
   return ""
}

func (m *CameraTaskArgs) GetGroupId() string {
func (m *Rule) GetGroupId() string {
   if m != nil {
      return m.GroupId
   }
@@ -1017,7 +1357,7 @@
func (m *Sdk) String() string { return proto.CompactTextString(m) }
func (*Sdk) ProtoMessage()    {}
func (*Sdk) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{12}
   return fileDescriptor_32de24555f916688, []int{17}
}
func (m *Sdk) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1137,7 +1477,7 @@
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{13}
   return fileDescriptor_32de24555f916688, []int{18}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1218,7 +1558,7 @@
func (m *Point) String() string { return proto.CompactTextString(m) }
func (*Point) ProtoMessage()    {}
func (*Point) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{14}
   return fileDescriptor_32de24555f916688, []int{19}
}
func (m *Point) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1272,7 +1612,7 @@
func (m *Rect) String() string { return proto.CompactTextString(m) }
func (*Rect) ProtoMessage()    {}
func (*Rect) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{15}
   return fileDescriptor_32de24555f916688, []int{20}
}
func (m *Rect) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1340,7 +1680,7 @@
func (m *FaceAngle) String() string { return proto.CompactTextString(m) }
func (*FaceAngle) ProtoMessage()    {}
func (*FaceAngle) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{16}
   return fileDescriptor_32de24555f916688, []int{21}
}
func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1409,7 +1749,7 @@
func (m *ThftResult) String() string { return proto.CompactTextString(m) }
func (*ThftResult) ProtoMessage()    {}
func (*ThftResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{17}
   return fileDescriptor_32de24555f916688, []int{22}
}
func (m *ThftResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1488,7 +1828,7 @@
func (m *FacePos) String() string { return proto.CompactTextString(m) }
func (*FacePos) ProtoMessage()    {}
func (*FacePos) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{18}
   return fileDescriptor_32de24555f916688, []int{23}
}
func (m *FacePos) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1589,7 +1929,7 @@
func (m *FaceInfo) String() string { return proto.CompactTextString(m) }
func (*FaceInfo) ProtoMessage()    {}
func (*FaceInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{19}
   return fileDescriptor_32de24555f916688, []int{24}
}
func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1691,7 +2031,7 @@
func (m *ObjInfo) String() string { return proto.CompactTextString(m) }
func (*ObjInfo) ProtoMessage()    {}
func (*ObjInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{20}
   return fileDescriptor_32de24555f916688, []int{25}
}
func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1742,23 +2082,23 @@
}

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

func (m *ParamFaceProperty) Reset()         { *m = ParamFaceProperty{} }
func (m *ParamFaceProperty) String() string { return proto.CompactTextString(m) }
func (*ParamFaceProperty) ProtoMessage()    {}
func (*ParamFaceProperty) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{21}
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{26}
}
func (m *ParamFaceProperty) XXX_Unmarshal(b []byte) error {
func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *ParamFaceProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *ParamFacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_ParamFaceProperty.Marshal(b, m, deterministic)
      return xxx_messageInfo_ParamFacePos.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
@@ -1768,26 +2108,26 @@
      return b[:n], nil
   }
}
func (m *ParamFaceProperty) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ParamFaceProperty.Merge(m, src)
func (m *ParamFacePos) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ParamFacePos.Merge(m, src)
}
func (m *ParamFaceProperty) XXX_Size() int {
func (m *ParamFacePos) XXX_Size() int {
   return m.Size()
}
func (m *ParamFaceProperty) XXX_DiscardUnknown() {
   xxx_messageInfo_ParamFaceProperty.DiscardUnknown(m)
func (m *ParamFacePos) XXX_DiscardUnknown() {
   xxx_messageInfo_ParamFacePos.DiscardUnknown(m)
}

var xxx_messageInfo_ParamFaceProperty proto.InternalMessageInfo
var xxx_messageInfo_ParamFacePos proto.InternalMessageInfo

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

func (m *ParamFaceProperty) GetImg() *Image {
func (m *ParamFacePos) GetImg() *Image {
   if m != nil {
      return m.Img
   }
@@ -1804,7 +2144,7 @@
func (m *ParamFaceCompare) String() string { return proto.CompactTextString(m) }
func (*ParamFaceCompare) ProtoMessage()    {}
func (*ParamFaceCompare) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{22}
   return fileDescriptor_32de24555f916688, []int{27}
}
func (m *ParamFaceCompare) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1847,19 +2187,301 @@
   return nil
}

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

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

var xxx_messageInfo_ParamFaceProperty proto.InternalMessageInfo

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

func (m *ParamFaceProperty) GetImg() *Image {
   if m != nil {
      return m.Img
   }
   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{29}
}
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
}

//publish db change message
type DbChangeMessage struct {
   Table  TableChanged `protobuf:"varint,1,opt,name=table,proto3,enum=protomsg.TableChanged" json:"table,omitempty"`
   Id     string       `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
   Action DbAction     `protobuf:"varint,3,opt,name=action,proto3,enum=protomsg.DbAction" json:"action,omitempty"`
   Info   string       `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
}

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

var xxx_messageInfo_DbChangeMessage proto.InternalMessageInfo

func (m *DbChangeMessage) GetTable() TableChanged {
   if m != nil {
      return m.Table
   }
   return TableChanged_T_Camera
}

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

func (m *DbChangeMessage) GetAction() DbAction {
   if m != nil {
      return m.Action
   }
   return DbAction_Insert
}

func (m *DbChangeMessage) GetInfo() string {
   if m != nil {
      return m.Info
   }
   return ""
}

type CameraPolygon struct {
   Id            string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraId      string `protobuf:"bytes,2,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   Name          string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
   Polygon       string `protobuf:"bytes,4,opt,name=polygon,proto3" json:"polygon,omitempty"`
   TriggerLine   string `protobuf:"bytes,5,opt,name=trigger_line,json=triggerLine,proto3" json:"trigger_line,omitempty"`
   DirectionLine string `protobuf:"bytes,6,opt,name=direction_line,json=directionLine,proto3" json:"direction_line,omitempty"`
   Type          string `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
   DefenceState  int32  `protobuf:"varint,8,opt,name=defence_state,json=defenceState,proto3" json:"defence_state,omitempty"`
}

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

var xxx_messageInfo_CameraPolygon proto.InternalMessageInfo

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

func (m *CameraPolygon) GetCameraId() string {
   if m != nil {
      return m.CameraId
   }
   return ""
}

func (m *CameraPolygon) GetName() string {
   if m != nil {
      return m.Name
   }
   return ""
}

func (m *CameraPolygon) GetPolygon() string {
   if m != nil {
      return m.Polygon
   }
   return ""
}

func (m *CameraPolygon) GetTriggerLine() string {
   if m != nil {
      return m.TriggerLine
   }
   return ""
}

func (m *CameraPolygon) GetDirectionLine() string {
   if m != nil {
      return m.DirectionLine
   }
   return ""
}

func (m *CameraPolygon) GetType() string {
   if m != nil {
      return m.Type
   }
   return ""
}

func (m *CameraPolygon) GetDefenceState() int32 {
   if m != nil {
      return m.DefenceState
   }
   return 0
}

func init() {
   proto.RegisterEnum("protomsg.TableChanged", TableChanged_name, TableChanged_value)
   proto.RegisterEnum("protomsg.DbAction", DbAction_name, DbAction_value)
   proto.RegisterType((*TaskLabel)(nil), "protomsg.TaskLabel")
   proto.RegisterType((*SdkMessage)(nil), "protomsg.SdkMessage")
   proto.RegisterType((*Image)(nil), "protomsg.Image")
   proto.RegisterType((*Area)(nil), "protomsg.Area")
   proto.RegisterType((*Camera)(nil), "protomsg.Camera")
   proto.RegisterType((*CameraAndTaskInfo)(nil), "protomsg.CameraAndTaskInfo")
   proto.RegisterType((*Task)(nil), "protomsg.Task")
   proto.RegisterType((*TaskSdkInfo)(nil), "protomsg.TaskSdkInfo")
   proto.RegisterType((*CameraTask)(nil), "protomsg.CameraTask")
   proto.RegisterType((*CameraTimerule)(nil), "protomsg.CameraTimerule")
   proto.RegisterType((*DayCtl)(nil), "protomsg.DayCtl")
   proto.RegisterType((*TimeRange)(nil), "protomsg.TimeRange")
   proto.RegisterType((*Polygon)(nil), "protomsg.Polygon")
   proto.RegisterType((*CameraTaskArgs)(nil), "protomsg.CameraTaskArgs")
   proto.RegisterType((*TaskGroupArgs)(nil), "protomsg.TaskGroupArgs")
   proto.RegisterType((*GroupRule)(nil), "protomsg.GroupRule")
   proto.RegisterType((*Rule)(nil), "protomsg.Rule")
   proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
   proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
   proto.RegisterType((*Point)(nil), "protomsg.Point")
@@ -1869,110 +2491,141 @@
   proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
   proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
   proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
   proto.RegisterType((*ParamFaceProperty)(nil), "protomsg.ParamFaceProperty")
   proto.RegisterType((*ParamFacePos)(nil), "protomsg.ParamFacePos")
   proto.RegisterType((*ParamFaceCompare)(nil), "protomsg.ParamFaceCompare")
   proto.RegisterType((*ParamFaceProperty)(nil), "protomsg.ParamFaceProperty")
   proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
   proto.RegisterType((*DbChangeMessage)(nil), "protomsg.DbChangeMessage")
   proto.RegisterType((*CameraPolygon)(nil), "protomsg.CameraPolygon")
}

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

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

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
@@ -2226,6 +2879,46 @@
   return i, nil
}

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

func (m *Task) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -2323,11 +3016,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Task.Size()))
      n2, err2 := m.Task.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      n3, err3 := m.Task.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      }
      i += n2
      i += n3
   }
   if len(m.Sdks) > 0 {
      for _, msg := range m.Sdks {
@@ -2455,6 +3148,42 @@
   return i, nil
}

func (m *CameraTimerule) 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 *CameraTimerule) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.Name) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
      i += copy(dAtA[i:], m.Name)
   }
   if len(m.TimeRule) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeRule)))
      i += copy(dAtA[i:], m.TimeRule)
   }
   return i, nil
}

func (m *DayCtl) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -2549,7 +3278,7 @@
   }
   if len(m.Points) > 0 {
      for _, msg := range m.Points {
         dAtA[i] = 0x22
         dAtA[i] = 0x1a
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
@@ -2573,6 +3302,114 @@
}

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

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

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

func (m *Rule) 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 *Rule) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2636,11 +3473,11 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   if len(m.RuleWithNext) > 0 {
   if len(m.RuleWithPre) > 0 {
      dAtA[i] = 0x5a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithNext)))
      i += copy(dAtA[i:], m.RuleWithNext)
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithPre)))
      i += copy(dAtA[i:], m.RuleWithPre)
   }
   if len(m.GroupId) > 0 {
      dAtA[i] = 0x62
@@ -2965,61 +3802,61 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
      n3, err3 := m.RcFace.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      }
      i += n3
   }
   if m.PtLeftEye != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
      n4, err4 := m.PtLeftEye.MarshalTo(dAtA[i:])
      n4, err4 := m.RcFace.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n4
   }
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
   if m.PtLeftEye != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
      n5, err5 := m.PtRightEye.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
      n5, err5 := m.PtLeftEye.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n5
   }
   if m.PtMouth != nil {
      dAtA[i] = 0x22
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
      n6, err6 := m.PtMouth.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
      n6, err6 := m.PtRightEye.MarshalTo(dAtA[i:])
      if err6 != nil {
         return 0, err6
      }
      i += n6
   }
   if m.PtNose != nil {
      dAtA[i] = 0x2a
   if m.PtMouth != nil {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
      n7, err7 := m.PtNose.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
      n7, err7 := m.PtMouth.MarshalTo(dAtA[i:])
      if err7 != nil {
         return 0, err7
      }
      i += n7
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
   if m.PtNose != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
      n8, err8 := m.FAngle.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
      n8, err8 := m.PtNose.MarshalTo(dAtA[i:])
      if err8 != nil {
         return 0, err8
      }
      i += n8
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
      n9, err9 := m.FAngle.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n9
   }
   if m.Quality != 0 {
      dAtA[i] = 0x38
@@ -3054,61 +3891,61 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
      n9, err9 := m.RcFace.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n9
   }
   if m.PtLeftEye != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
      n10, err10 := m.PtLeftEye.MarshalTo(dAtA[i:])
      n10, err10 := m.RcFace.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      }
      i += n10
   }
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
   if m.PtLeftEye != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
      n11, err11 := m.PtRightEye.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
      n11, err11 := m.PtLeftEye.MarshalTo(dAtA[i:])
      if err11 != nil {
         return 0, err11
      }
      i += n11
   }
   if m.PtMouth != nil {
      dAtA[i] = 0x22
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
      n12, err12 := m.PtMouth.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
      n12, err12 := m.PtRightEye.MarshalTo(dAtA[i:])
      if err12 != nil {
         return 0, err12
      }
      i += n12
   }
   if m.PtNose != nil {
      dAtA[i] = 0x2a
   if m.PtMouth != nil {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
      n13, err13 := m.PtNose.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
      n13, err13 := m.PtMouth.MarshalTo(dAtA[i:])
      if err13 != nil {
         return 0, err13
      }
      i += n13
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
   if m.PtNose != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
      n14, err14 := m.FAngle.MarshalTo(dAtA[i:])
      i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
      n14, err14 := m.PtNose.MarshalTo(dAtA[i:])
      if err14 != nil {
         return 0, err14
      }
      i += n14
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
      n15, err15 := m.FAngle.MarshalTo(dAtA[i:])
      if err15 != nil {
         return 0, err15
      }
      i += n15
   }
   if m.Quality != 0 {
      dAtA[i] = 0x38
@@ -3148,11 +3985,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.RcObj.Size()))
      n15, err15 := m.RcObj.MarshalTo(dAtA[i:])
      if err15 != nil {
         return 0, err15
      n16, err16 := m.RcObj.MarshalTo(dAtA[i:])
      if err16 != nil {
         return 0, err16
      }
      i += n15
      i += n16
   }
   if m.Typ != 0 {
      dAtA[i] = 0x10
@@ -3168,7 +4005,7 @@
   return i, nil
}

func (m *ParamFaceProperty) Marshal() (dAtA []byte, err error) {
func (m *ParamFacePos) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -3178,7 +4015,7 @@
   return dAtA[:n], nil
}

func (m *ParamFaceProperty) MarshalTo(dAtA []byte) (int, error) {
func (m *ParamFacePos) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -3187,21 +4024,21 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Pos.Size()))
      n16, err16 := m.Pos.MarshalTo(dAtA[i:])
      if err16 != nil {
         return 0, err16
      n17, err17 := m.Pos.MarshalTo(dAtA[i:])
      if err17 != nil {
         return 0, err17
      }
      i += n16
      i += n17
   }
   if m.Img != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Img.Size()))
      n17, err17 := m.Img.MarshalTo(dAtA[i:])
      if err17 != nil {
         return 0, err17
      n18, err18 := m.Img.MarshalTo(dAtA[i:])
      if err18 != nil {
         return 0, err18
      }
      i += n17
      i += n18
   }
   return i, nil
}
@@ -3232,6 +4069,189 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat2)))
      i += copy(dAtA[i:], m.Feat2)
   }
   return i, nil
}

func (m *ParamFaceProperty) 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 *ParamFaceProperty) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Result != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Result.Size()))
      n19, err19 := m.Result.MarshalTo(dAtA[i:])
      if err19 != nil {
         return 0, err19
      }
      i += n19
   }
   if m.Img != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Img.Size()))
      n20, err20 := m.Img.MarshalTo(dAtA[i:])
      if err20 != nil {
         return 0, err20
      }
      i += n20
   }
   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()))
      n21, err21 := m.Img.MarshalTo(dAtA[i:])
      if err21 != nil {
         return 0, err21
      }
      i += n21
   }
   return i, nil
}

func (m *DbChangeMessage) 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 *DbChangeMessage) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Table != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Table))
   }
   if len(m.Id) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if m.Action != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Action))
   }
   if len(m.Info) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Info)))
      i += copy(dAtA[i:], m.Info)
   }
   return i, nil
}

func (m *CameraPolygon) 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 *CameraPolygon) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.CameraId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
      i += copy(dAtA[i:], m.CameraId)
   }
   if len(m.Name) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
      i += copy(dAtA[i:], m.Name)
   }
   if len(m.Polygon) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Polygon)))
      i += copy(dAtA[i:], m.Polygon)
   }
   if len(m.TriggerLine) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TriggerLine)))
      i += copy(dAtA[i:], m.TriggerLine)
   }
   if len(m.DirectionLine) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.DirectionLine)))
      i += copy(dAtA[i:], m.DirectionLine)
   }
   if len(m.Type) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Type)))
      i += copy(dAtA[i:], m.Type)
   }
   if m.DefenceState != 0 {
      dAtA[i] = 0x40
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.DefenceState))
   }
   return i, nil
}
@@ -3386,6 +4406,25 @@
   return n
}

func (m *CameraAndTaskInfo) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Camera != nil {
      l = m.Camera.Size()
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.Tasks) > 0 {
      for _, e := range m.Tasks {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   return n
}

func (m *Task) Size() (n int) {
   if m == nil {
      return 0
@@ -3497,6 +4536,27 @@
   return n
}

func (m *CameraTimerule) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Name)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.TimeRule)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *DayCtl) Size() (n int) {
   if m == nil {
      return 0
@@ -3561,6 +4621,63 @@
   }
   var l int
   _ = l
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.TaskArgs) > 0 {
      for _, e := range m.TaskArgs {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   return n
}

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

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

func (m *Rule) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
@@ -3600,7 +4717,7 @@
   if m.Sort != 0 {
      n += 1 + sovProtomsg(uint64(m.Sort))
   }
   l = len(m.RuleWithNext)
   l = len(m.RuleWithPre)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
@@ -3880,7 +4997,7 @@
   return n
}

func (m *ParamFaceProperty) Size() (n int) {
func (m *ParamFacePos) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -3910,6 +5027,105 @@
   l = len(m.Feat2)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

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

func (m *DbChangeMessage) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Table != 0 {
      n += 1 + sovProtomsg(uint64(m.Table))
   }
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Action != 0 {
      n += 1 + sovProtomsg(uint64(m.Action))
   }
   l = len(m.Info)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *CameraPolygon) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Name)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Polygon)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.TriggerLine)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.DirectionLine)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Type)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.DefenceState != 0 {
      n += 1 + sovProtomsg(uint64(m.DefenceState))
   }
   return n
}
@@ -4886,6 +6102,129 @@
   }
   return nil
}
func (m *CameraAndTaskInfo) 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: CameraAndTaskInfo: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraAndTaskInfo: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Camera", 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.Camera == nil {
            m.Camera = &Camera{}
         }
         if err := m.Camera.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Tasks", 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.Tasks = append(m.Tasks, &Task{})
         if err := m.Tasks[len(m.Tasks)-1].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 *Task) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
@@ -5660,6 +6999,155 @@
   }
   return nil
}
func (m *CameraTimerule) 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: CameraTimerule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraTimerule: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Name = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TimeRule", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TimeRule = string(dAtA[iNdEx:postIndex])
         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 *DayCtl) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
@@ -5976,7 +7464,7 @@
         }
         m.Name = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Points", wireType)
         }
@@ -6061,6 +7549,363 @@
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraTaskArgs: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TaskArgs", 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.TaskArgs = append(m.TaskArgs, &TaskGroupArgs{})
         if err := m.TaskArgs[len(m.TaskArgs)-1].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 *TaskGroupArgs) 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: TaskGroupArgs: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: TaskGroupArgs: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TaskId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field GroupRules", 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.GroupRules = append(m.GroupRules, &GroupRule{})
         if err := m.GroupRules[len(m.GroupRules)-1].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 *GroupRule) 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: GroupRule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: GroupRule: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.GroupId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Rules", 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.Rules = append(m.Rules, &Rule{})
         if err := m.Rules[len(m.Rules)-1].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 *Rule) 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: Rule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -6372,7 +8217,7 @@
         }
      case 11:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RuleWithNext", wireType)
            return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
@@ -6400,7 +8245,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.RuleWithNext = string(dAtA[iNdEx:postIndex])
         m.RuleWithPre = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 12:
         if wireType != 2 {
@@ -8356,7 +10201,7 @@
   }
   return nil
}
func (m *ParamFaceProperty) Unmarshal(dAtA []byte) error {
func (m *ParamFacePos) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -8379,10 +10224,10 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: ParamFaceProperty: wiretype end group for non-group")
         return fmt.Errorf("proto: ParamFacePos: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ParamFaceProperty: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: ParamFacePos: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -8602,6 +10447,705 @@
   }
   return nil
}
func (m *ParamFaceProperty) 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: ParamFaceProperty: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ParamFaceProperty: 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 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 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 (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 (m *DbChangeMessage) 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: DbChangeMessage: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: DbChangeMessage: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
         }
         m.Table = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Table |= TableChanged(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
         }
         m.Action = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Action |= DbAction(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Info = string(dAtA[iNdEx:postIndex])
         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 *CameraPolygon) 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: CameraPolygon: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraPolygon: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Name = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Polygon", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Polygon = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TriggerLine", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TriggerLine = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field DirectionLine", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.DirectionLine = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            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 ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Type = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field DefenceState", wireType)
         }
         m.DefenceState = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.DefenceState |= 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 skipProtomsg(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0