pubsub/protomsg.git

			@@ -82,6 +82,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"`
			@@ -203,6 +204,1064 @@
			return nil
			}

			//Area结构体
			type Area struct {
			Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
			Parentid int32 `protobuf:"varint,2,opt,name=parentid,proto3" json:"parentid,omitempty"`
			Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
			}

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

			var xxx_messageInfo_Area proto.InternalMessageInfo

			func (m *Area) GetId() int32 {
			if m != nil {
			return m.Id
			}
			return 0
			}

			func (m *Area) GetParentid() int32 {
			if m != nil {
			return m.Parentid
			}
			return 0
			}

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

			//Camera结构体
			type Camera 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"`
			Type int32 `protobuf:"varint,3,opt,name=type,proto3" json:"type,omitempty"`
			Addr string `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
			Areaid int32 `protobuf:"varint,5,opt,name=areaid,proto3" json:"areaid,omitempty"`
			Longitude float32 `protobuf:"fixed32,6,opt,name=longitude,proto3" json:"longitude,omitempty"`
			Latitude float32 `protobuf:"fixed32,7,opt,name=latitude,proto3" json:"latitude,omitempty"`
			Rtsp string `protobuf:"bytes,8,opt,name=rtsp,proto3" json:"rtsp,omitempty"`
			Ip string `protobuf:"bytes,9,opt,name=ip,proto3" json:"ip,omitempty"`
			Port int32 `protobuf:"varint,10,opt,name=port,proto3" json:"port,omitempty"`
			Username string `protobuf:"bytes,11,opt,name=username,proto3" json:"username,omitempty"`
			Password string `protobuf:"bytes,12,opt,name=password,proto3" json:"password,omitempty"`
			Brand string `protobuf:"bytes,13,opt,name=brand,proto3" json:"brand,omitempty"`
			Reserved string `protobuf:"bytes,14,opt,name=reserved,proto3" json:"reserved,omitempty"`
			}

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

			var xxx_messageInfo_Camera proto.InternalMessageInfo

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

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

			func (m *Camera) GetType() int32 {
			if m != nil {
			return m.Type
			}
			return 0
			}

			func (m *Camera) GetAddr() string {
			if m != nil {
			return m.Addr
			}
			return ""
			}

			func (m *Camera) GetAreaid() int32 {
			if m != nil {
			return m.Areaid
			}
			return 0
			}

			func (m *Camera) GetLongitude() float32 {
			if m != nil {
			return m.Longitude
			}
			return 0
			}

			func (m *Camera) GetLatitude() float32 {
			if m != nil {
			return m.Latitude
			}
			return 0
			}

			func (m *Camera) GetRtsp() string {
			if m != nil {
			return m.Rtsp
			}
			return ""
			}

			func (m *Camera) GetIp() string {
			if m != nil {
			return m.Ip
			}
			return ""
			}

			func (m *Camera) GetPort() int32 {
			if m != nil {
			return m.Port
			}
			return 0
			}

			func (m *Camera) GetUsername() string {
			if m != nil {
			return m.Username
			}
			return ""
			}

			func (m *Camera) GetPassword() string {
			if m != nil {
			return m.Password
			}
			return ""
			}

			func (m *Camera) GetBrand() string {
			if m != nil {
			return m.Brand
			}
			return ""
			}

			func (m *Camera) GetReserved() string {
			if m != nil {
			return m.Reserved
			}
			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"`
			Taskname string `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
			CreateAt string `protobuf:"bytes,3,opt,name=create_at,json=createAt,proto3" json:"create_at,omitempty"`
			CreateBy string `protobuf:"bytes,4,opt,name=create_by,json=createBy,proto3" json:"create_by,omitempty"`
			UpdateAt string `protobuf:"bytes,5,opt,name=update_at,json=updateAt,proto3" json:"update_at,omitempty"`
			Enable bool `protobuf:"varint,6,opt,name=enable,proto3" json:"enable,omitempty"`
			IsAlarm bool `protobuf:"varint,7,opt,name=is_alarm,json=isAlarm,proto3" json:"is_alarm,omitempty"`
			DelFlag bool `protobuf:"varint,8,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
			}

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

			var xxx_messageInfo_Task proto.InternalMessageInfo

			func (m *Task) GetTaskid() string {
			if m != nil {
			return m.Taskid
			}
			return ""
			}

			func (m *Task) GetTaskname() string {
			if m != nil {
			return m.Taskname
			}
			return ""
			}

			func (m *Task) GetCreateAt() string {
			if m != nil {
			return m.CreateAt
			}
			return ""
			}

			func (m *Task) GetCreateBy() string {
			if m != nil {
			return m.CreateBy
			}
			return ""
			}

			func (m *Task) GetUpdateAt() string {
			if m != nil {
			return m.UpdateAt
			}
			return ""
			}

			func (m *Task) GetEnable() bool {
			if m != nil {
			return m.Enable
			}
			return false
			}

			func (m *Task) GetIsAlarm() bool {
			if m != nil {
			return m.IsAlarm
			}
			return false
			}

			func (m *Task) GetDelFlag() bool {
			if m != nil {
			return m.DelFlag
			}
			return false
			}

			type TaskSdkInfo struct {
			Task *Task `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
			Sdks []*Sdk `protobuf:"bytes,2,rep,name=sdks,proto3" json:"sdks,omitempty"`
			}

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

			var xxx_messageInfo_TaskSdkInfo proto.InternalMessageInfo

			func (m TaskSdkInfo) GetTask() Task {
			if m != nil {
			return m.Task
			}
			return nil
			}

			func (m TaskSdkInfo) GetSdks() []Sdk {
			if m != nil {
			return m.Sdks
			}
			return nil
			}

			//摄像机任务
			type CameraTask struct {
			Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
			CameraIds string `protobuf:"bytes,2,opt,name=camera_ids,json=cameraIds,proto3" json:"camera_ids,omitempty"`
			TaskId string `protobuf:"bytes,3,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
			TimeRule []*DayCtl `protobuf:"bytes,4,rep,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
			ReactRule string `protobuf:"bytes,5,opt,name=react_rule,json=reactRule,proto3" json:"react_rule,omitempty"`
			ReactDevice string `protobuf:"bytes,6,opt,name=react_device,json=reactDevice,proto3" json:"react_device,omitempty"`
			DelFlag bool `protobuf:"varint,7,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
			UpdateFlag bool `protobuf:"varint,8,opt,name=update_flag,json=updateFlag,proto3" json:"update_flag,omitempty"`
			Enable bool `protobuf:"varint,9,opt,name=enable,proto3" json:"enable,omitempty"`
			Sort int32 `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
			IsFull bool `protobuf:"varint,11,opt,name=is_full,json=isFull,proto3" json:"is_full,omitempty"`
			LinkGroupId string `protobuf:"bytes,12,opt,name=link_group_id,json=linkGroupId,proto3" json:"link_group_id,omitempty"`
			}

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

			var xxx_messageInfo_CameraTask proto.InternalMessageInfo

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

			func (m *CameraTask) GetCameraIds() string {
			if m != nil {
			return m.CameraIds
			}
			return ""
			}

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

			func (m CameraTask) GetTimeRule() []DayCtl {
			if m != nil {
			return m.TimeRule
			}
			return nil
			}

			func (m *CameraTask) GetReactRule() string {
			if m != nil {
			return m.ReactRule
			}
			return ""
			}

			func (m *CameraTask) GetReactDevice() string {
			if m != nil {
			return m.ReactDevice
			}
			return ""
			}

			func (m *CameraTask) GetDelFlag() bool {
			if m != nil {
			return m.DelFlag
			}
			return false
			}

			func (m *CameraTask) GetUpdateFlag() bool {
			if m != nil {
			return m.UpdateFlag
			}
			return false
			}

			func (m *CameraTask) GetEnable() bool {
			if m != nil {
			return m.Enable
			}
			return false
			}

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

			func (m *CameraTask) GetIsFull() bool {
			if m != nil {
			return m.IsFull
			}
			return false
			}

			func (m *CameraTask) GetLinkGroupId() string {
			if m != nil {
			return m.LinkGroupId
			}
			return ""
			}

			//DayCtl struct 每天的时间控制规则
			type DayCtl struct {
			Day int32 `protobuf:"varint,1,opt,name=day,proto3" json:"day,omitempty"`
			TimeRange []*TimeRange `protobuf:"bytes,2,rep,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`
			}

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

			var xxx_messageInfo_DayCtl proto.InternalMessageInfo

			func (m *DayCtl) GetDay() int32 {
			if m != nil {
			return m.Day
			}
			return 0
			}

			func (m DayCtl) GetTimeRange() []TimeRange {
			if m != nil {
			return m.TimeRange
			}
			return nil
			}

			//时间起始范围
			type TimeRange struct {
			Start string `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
			End string `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
			}

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

			var xxx_messageInfo_TimeRange proto.InternalMessageInfo

			func (m *TimeRange) GetStart() string {
			if m != nil {
			return m.Start
			}
			return ""
			}

			func (m *TimeRange) GetEnd() string {
			if m != nil {
			return m.End
			}
			return ""
			}

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

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

			var xxx_messageInfo_Polygon proto.InternalMessageInfo

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

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

			func (m Polygon) GetPoints() []Point {
			if m != nil {
			return m.Points
			}
			return nil
			}

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

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

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

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

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

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

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

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

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

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

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

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

			//Sdk struct
			type Sdk struct {
			Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
			SdkType string `protobuf:"bytes,2,opt,name=sdk_type,json=sdkType,proto3" json:"sdk_type,omitempty"`
			SdkName string `protobuf:"bytes,3,opt,name=sdk_name,json=sdkName,proto3" json:"sdk_name,omitempty"`
			Args []*SdkArg `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
			Icon string `protobuf:"bytes,5,opt,name=icon,proto3" json:"icon,omitempty"`
			Url string `protobuf:"bytes,6,opt,name=url,proto3" json:"url,omitempty"`
			CreateTime string `protobuf:"bytes,7,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
			UpdateTime string `protobuf:"bytes,8,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
			CreateBy string `protobuf:"bytes,9,opt,name=create_by,json=createBy,proto3" json:"create_by,omitempty"`
			Enabled string `protobuf:"bytes,10,opt,name=enabled,proto3" json:"enabled,omitempty"`
			DelFlag string `protobuf:"bytes,11,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
			}

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

			var xxx_messageInfo_Sdk proto.InternalMessageInfo

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

			func (m *Sdk) GetSdkType() string {
			if m != nil {
			return m.SdkType
			}
			return ""
			}

			func (m *Sdk) GetSdkName() string {
			if m != nil {
			return m.SdkName
			}
			return ""
			}

			func (m Sdk) GetArgs() []SdkArg {
			if m != nil {
			return m.Args
			}
			return nil
			}

			func (m *Sdk) GetIcon() string {
			if m != nil {
			return m.Icon
			}
			return ""
			}

			func (m *Sdk) GetUrl() string {
			if m != nil {
			return m.Url
			}
			return ""
			}

			func (m *Sdk) GetCreateTime() string {
			if m != nil {
			return m.CreateTime
			}
			return ""
			}

			func (m *Sdk) GetUpdateTime() string {
			if m != nil {
			return m.UpdateTime
			}
			return ""
			}

			func (m *Sdk) GetCreateBy() string {
			if m != nil {
			return m.CreateBy
			}
			return ""
			}

			func (m *Sdk) GetEnabled() string {
			if m != nil {
			return m.Enabled
			}
			return ""
			}

			func (m *Sdk) GetDelFlag() string {
			if m != nil {
			return m.DelFlag
			}
			return ""
			}

			//SdkArg struct
			type SdkArg struct {
			Alias string `protobuf:"bytes,2,opt,name=alias,proto3" json:"alias,omitempty"`
			Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
			Type string `protobuf:"bytes,4,opt,name=type,proto3" json:"type,omitempty"`
			Must bool `protobuf:"varint,5,opt,name=must,proto3" json:"must,omitempty"`
			Range string `protobuf:"bytes,6,opt,name=range,proto3" json:"range,omitempty"`
			Sort int32 `protobuf:"varint,7,opt,name=sort,proto3" json:"sort,omitempty"`
			}

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

			var xxx_messageInfo_SdkArg proto.InternalMessageInfo

			func (m *SdkArg) GetAlias() string {
			if m != nil {
			return m.Alias
			}
			return ""
			}

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

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

			func (m *SdkArg) GetMust() bool {
			if m != nil {
			return m.Must
			}
			return false
			}

			func (m *SdkArg) GetRange() string {
			if m != nil {
			return m.Range
			}
			return ""
			}

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

			// struct for sdk
			type Point struct {
			X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
			@@ -213,7 +1272,7 @@
			func (m *Point) String() string { return proto.CompactTextString(m) }
			func (*Point) ProtoMessage() {}
			func (*Point) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{3}
			return fileDescriptor_32de24555f916688, []int{15}
			}
			func (m *Point) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -267,7 +1326,7 @@
			func (m *Rect) String() string { return proto.CompactTextString(m) }
			func (*Rect) ProtoMessage() {}
			func (*Rect) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{4}
			return fileDescriptor_32de24555f916688, []int{16}
			}
			func (m *Rect) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -335,7 +1394,7 @@
			func (m *FaceAngle) String() string { return proto.CompactTextString(m) }
			func (*FaceAngle) ProtoMessage() {}
			func (*FaceAngle) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{5}
			return fileDescriptor_32de24555f916688, []int{17}
			}
			func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -404,7 +1463,7 @@
			func (m *ThftResult) String() string { return proto.CompactTextString(m) }
			func (*ThftResult) ProtoMessage() {}
			func (*ThftResult) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{6}
			return fileDescriptor_32de24555f916688, []int{18}
			}
			func (m *ThftResult) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -483,7 +1542,7 @@
			func (m *FacePos) String() string { return proto.CompactTextString(m) }
			func (*FacePos) ProtoMessage() {}
			func (*FacePos) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{7}
			return fileDescriptor_32de24555f916688, []int{19}
			}
			func (m *FacePos) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -584,7 +1643,7 @@
			func (m *FaceInfo) String() string { return proto.CompactTextString(m) }
			func (*FaceInfo) ProtoMessage() {}
			func (*FaceInfo) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{8}
			return fileDescriptor_32de24555f916688, []int{20}
			}
			func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -686,7 +1745,7 @@
			func (m *ObjInfo) String() string { return proto.CompactTextString(m) }
			func (*ObjInfo) ProtoMessage() {}
			func (*ObjInfo) Descriptor() ([]byte, []int) {
			return fileDescriptor_32de24555f916688, []int{9}
			return fileDescriptor_32de24555f916688, []int{21}
			}
			func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -736,10 +1795,128 @@
			return 0
			}

			// sdk face property
			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 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{22}
			}
			func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			}
			func (m *ParamFacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
			if deterministic {
			return xxx_messageInfo_ParamFacePos.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalTo(b)
			if err != nil {
			return nil, err
			}
			return b[:n], nil
			}
			}
			func (m *ParamFacePos) XXX_Merge(src proto.Message) {
			xxx_messageInfo_ParamFacePos.Merge(m, src)
			}
			func (m *ParamFacePos) XXX_Size() int {
			return m.Size()
			}
			func (m *ParamFacePos) XXX_DiscardUnknown() {
			xxx_messageInfo_ParamFacePos.DiscardUnknown(m)
			}

			var xxx_messageInfo_ParamFacePos proto.InternalMessageInfo

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

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

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

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

			var xxx_messageInfo_ParamFaceCompare proto.InternalMessageInfo

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

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

			func init() {
			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((*DayCtl)(nil), "protomsg.DayCtl")
			proto.RegisterType((*TimeRange)(nil), "protomsg.TimeRange")
			proto.RegisterType((*Polygon)(nil), "protomsg.Polygon")
			proto.RegisterType((*CameraTaskArgs)(nil), "protomsg.CameraTaskArgs")
			proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
			proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
			proto.RegisterType((*Point)(nil), "protomsg.Point")
			proto.RegisterType((*Rect)(nil), "protomsg.Rect")
			proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
			@@ -747,50 +1924,112 @@
			proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
			proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
			proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
			proto.RegisterType((*ParamFacePos)(nil), "protomsg.ParamFacePos")
			proto.RegisterType((*ParamFaceCompare)(nil), "protomsg.ParamFaceCompare")
			}

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

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

			func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
			@@ -907,6 +2146,751 @@
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
			i += copy(dAtA[i:], m.Data)
			}
			return i, nil
			}

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

			func (m *Camera) 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 *Camera) 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 m.Type != 0 {
			dAtA[i] = 0x18
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
			}
			if len(m.Addr) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Addr)))
			i += copy(dAtA[i:], m.Addr)
			}
			if m.Areaid != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Areaid))
			}
			if m.Longitude != 0 {
			dAtA[i] = 0x35
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Longitude))))
			i += 4
			}
			if m.Latitude != 0 {
			dAtA[i] = 0x3d
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Latitude))))
			i += 4
			}
			if len(m.Rtsp) > 0 {
			dAtA[i] = 0x42
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Rtsp)))
			i += copy(dAtA[i:], m.Rtsp)
			}
			if len(m.Ip) > 0 {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Ip)))
			i += copy(dAtA[i:], m.Ip)
			}
			if m.Port != 0 {
			dAtA[i] = 0x50
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Port))
			}
			if len(m.Username) > 0 {
			dAtA[i] = 0x5a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Username)))
			i += copy(dAtA[i:], m.Username)
			}
			if len(m.Password) > 0 {
			dAtA[i] = 0x62
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Password)))
			i += copy(dAtA[i:], m.Password)
			}
			if len(m.Brand) > 0 {
			dAtA[i] = 0x6a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Brand)))
			i += copy(dAtA[i:], m.Brand)
			}
			if len(m.Reserved) > 0 {
			dAtA[i] = 0x72
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Reserved)))
			i += copy(dAtA[i:], m.Reserved)
			}
			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)
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			return dAtA[:n], nil
			}

			func (m *Task) 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.Taskname) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Taskname)))
			i += copy(dAtA[i:], m.Taskname)
			}
			if len(m.CreateAt) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateAt)))
			i += copy(dAtA[i:], m.CreateAt)
			}
			if len(m.CreateBy) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateBy)))
			i += copy(dAtA[i:], m.CreateBy)
			}
			if len(m.UpdateAt) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.UpdateAt)))
			i += copy(dAtA[i:], m.UpdateAt)
			}
			if m.Enable {
			dAtA[i] = 0x30
			i++
			if m.Enable {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if m.IsAlarm {
			dAtA[i] = 0x38
			i++
			if m.IsAlarm {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if m.DelFlag {
			dAtA[i] = 0x40
			i++
			if m.DelFlag {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			return i, nil
			}

			func (m *TaskSdkInfo) 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 *TaskSdkInfo) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.Task != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Task.Size()))
			n3, err3 := m.Task.MarshalTo(dAtA[i:])
			if err3 != nil {
			return 0, err3
			}
			i += n3
			}
			if len(m.Sdks) > 0 {
			for _, msg := range m.Sdks {
			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 *CameraTask) 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 *CameraTask) 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.CameraIds) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraIds)))
			i += copy(dAtA[i:], m.CameraIds)
			}
			if len(m.TaskId) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TaskId)))
			i += copy(dAtA[i:], m.TaskId)
			}
			if len(m.TimeRule) > 0 {
			for _, msg := range m.TimeRule {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			if len(m.ReactRule) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ReactRule)))
			i += copy(dAtA[i:], m.ReactRule)
			}
			if len(m.ReactDevice) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ReactDevice)))
			i += copy(dAtA[i:], m.ReactDevice)
			}
			if m.DelFlag {
			dAtA[i] = 0x38
			i++
			if m.DelFlag {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if m.UpdateFlag {
			dAtA[i] = 0x40
			i++
			if m.UpdateFlag {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if m.Enable {
			dAtA[i] = 0x48
			i++
			if m.Enable {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if m.Sort != 0 {
			dAtA[i] = 0x50
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
			}
			if m.IsFull {
			dAtA[i] = 0x58
			i++
			if m.IsFull {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if len(m.LinkGroupId) > 0 {
			dAtA[i] = 0x62
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.LinkGroupId)))
			i += copy(dAtA[i:], m.LinkGroupId)
			}
			return i, nil
			}

			func (m *DayCtl) 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 *DayCtl) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.Day != 0 {
			dAtA[i] = 0x8
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Day))
			}
			if len(m.TimeRange) > 0 {
			for _, msg := range m.TimeRange {
			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 *TimeRange) 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 *TimeRange) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Start) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Start)))
			i += copy(dAtA[i:], m.Start)
			}
			if len(m.End) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.End)))
			i += copy(dAtA[i:], m.End)
			}
			return i, nil
			}

			func (m *Polygon) 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 *Polygon) 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.Points) > 0 {
			for _, msg := range m.Points {
			dAtA[i] = 0x22
			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 *CameraTaskArgs) 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 *CameraTaskArgs) 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.CameraTaskId) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraTaskId)))
			i += copy(dAtA[i:], m.CameraTaskId)
			}
			if len(m.CameraId) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
			i += copy(dAtA[i:], m.CameraId)
			}
			if len(m.PolygonId) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.PolygonId)))
			i += copy(dAtA[i:], m.PolygonId)
			}
			if len(m.SdkId) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkId)))
			i += copy(dAtA[i:], m.SdkId)
			}
			if len(m.SdkArgAlias) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgAlias)))
			i += copy(dAtA[i:], m.SdkArgAlias)
			}
			if len(m.Operator) > 0 {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
			i += copy(dAtA[i:], m.Operator)
			}
			if len(m.OperatorType) > 0 {
			dAtA[i] = 0x42
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.OperatorType)))
			i += copy(dAtA[i:], m.OperatorType)
			}
			if len(m.SdkArgValue) > 0 {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgValue)))
			i += copy(dAtA[i:], m.SdkArgValue)
			}
			if m.Sort != 0 {
			dAtA[i] = 0x50
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
			}
			if len(m.RuleWithNext) > 0 {
			dAtA[i] = 0x5a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithNext)))
			i += copy(dAtA[i:], m.RuleWithNext)
			}
			if len(m.GroupId) > 0 {
			dAtA[i] = 0x62
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
			i += copy(dAtA[i:], m.GroupId)
			}
			return i, nil
			}

			func (m *Sdk) 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 *Sdk) 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.SdkType) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkType)))
			i += copy(dAtA[i:], m.SdkType)
			}
			if len(m.SdkName) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkName)))
			i += copy(dAtA[i:], m.SdkName)
			}
			if len(m.Args) > 0 {
			for _, msg := range m.Args {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			if len(m.Icon) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Icon)))
			i += copy(dAtA[i:], m.Icon)
			}
			if len(m.Url) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Url)))
			i += copy(dAtA[i:], m.Url)
			}
			if len(m.CreateTime) > 0 {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateTime)))
			i += copy(dAtA[i:], m.CreateTime)
			}
			if len(m.UpdateTime) > 0 {
			dAtA[i] = 0x42
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.UpdateTime)))
			i += copy(dAtA[i:], m.UpdateTime)
			}
			if len(m.CreateBy) > 0 {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateBy)))
			i += copy(dAtA[i:], m.CreateBy)
			}
			if len(m.Enabled) > 0 {
			dAtA[i] = 0x52
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Enabled)))
			i += copy(dAtA[i:], m.Enabled)
			}
			if len(m.DelFlag) > 0 {
			dAtA[i] = 0x5a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.DelFlag)))
			i += copy(dAtA[i:], m.DelFlag)
			}
			return i, nil
			}

			func (m *SdkArg) 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 *SdkArg) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Alias) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Alias)))
			i += copy(dAtA[i:], m.Alias)
			}
			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.Type) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Type)))
			i += copy(dAtA[i:], m.Type)
			}
			if m.Must {
			dAtA[i] = 0x28
			i++
			if m.Must {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if len(m.Range) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Range)))
			i += copy(dAtA[i:], m.Range)
			}
			if m.Sort != 0 {
			dAtA[i] = 0x38
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
			}
			return i, nil
			}
			@@ -1078,61 +3062,61 @@
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
			n2, err2 := m.RcFace.MarshalTo(dAtA[i:])
			if err2 != nil {
			return 0, err2
			}
			i += n2
			}
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
			n3, err3 := m.PtLeftEye.MarshalTo(dAtA[i:])
			if err3 != nil {
			return 0, err3
			}
			i += n3
			}
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
			n4, err4 := m.PtRightEye.MarshalTo(dAtA[i:])
			n4, err4 := m.RcFace.MarshalTo(dAtA[i:])
			if err4 != nil {
			return 0, err4
			}
			i += n4
			}
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
			n5, err5 := m.PtMouth.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.PtNose != nil {
			dAtA[i] = 0x2a
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
			n6, err6 := m.PtNose.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.FAngle != nil {
			dAtA[i] = 0x32
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
			n7, err7 := m.FAngle.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.PtNose != nil {
			dAtA[i] = 0x2a
			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
			@@ -1167,61 +3151,61 @@
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
			n8, err8 := m.RcFace.MarshalTo(dAtA[i:])
			if err8 != nil {
			return 0, err8
			}
			i += n8
			}
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
			n9, err9 := m.PtLeftEye.MarshalTo(dAtA[i:])
			if err9 != nil {
			return 0, err9
			}
			i += n9
			}
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
			n10, err10 := m.PtRightEye.MarshalTo(dAtA[i:])
			n10, err10 := m.RcFace.MarshalTo(dAtA[i:])
			if err10 != nil {
			return 0, err10
			}
			i += n10
			}
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			if m.PtLeftEye != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
			n11, err11 := m.PtMouth.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.PtNose != nil {
			dAtA[i] = 0x2a
			if m.PtRightEye != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
			n12, err12 := m.PtNose.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.FAngle != nil {
			dAtA[i] = 0x32
			if m.PtMouth != nil {
			dAtA[i] = 0x22
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
			n13, err13 := m.FAngle.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.PtNose != nil {
			dAtA[i] = 0x2a
			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
			@@ -1261,11 +3245,11 @@
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.RcObj.Size()))
			n14, err14 := m.RcObj.MarshalTo(dAtA[i:])
			if err14 != nil {
			return 0, err14
			n16, err16 := m.RcObj.MarshalTo(dAtA[i:])
			if err16 != nil {
			return 0, err16
			}
			i += n14
			i += n16
			}
			if m.Typ != 0 {
			dAtA[i] = 0x10
			@@ -1277,6 +3261,74 @@
			i++
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
			i += 4
			}
			return i, nil
			}

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

			func (m *ParamFacePos) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.Pos != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Pos.Size()))
			n17, err17 := m.Pos.MarshalTo(dAtA[i:])
			if err17 != nil {
			return 0, err17
			}
			i += n17
			}
			if m.Img != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(m.Img.Size()))
			n18, err18 := m.Img.MarshalTo(dAtA[i:])
			if err18 != nil {
			return 0, err18
			}
			i += n18
			}
			return i, nil
			}

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

			func (m *ParamFaceCompare) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Feat1) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat1)))
			i += copy(dAtA[i:], m.Feat1)
			}
			if len(m.Feat2) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat2)))
			i += copy(dAtA[i:], m.Feat2)
			}
			return i, nil
			}
			@@ -1348,6 +3400,415 @@
			l = len(m.Data)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			return n
			}

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

			func (m *Camera) 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))
			}
			if m.Type != 0 {
			n += 1 + sovProtomsg(uint64(m.Type))
			}
			l = len(m.Addr)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.Areaid != 0 {
			n += 1 + sovProtomsg(uint64(m.Areaid))
			}
			if m.Longitude != 0 {
			n += 5
			}
			if m.Latitude != 0 {
			n += 5
			}
			l = len(m.Rtsp)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Ip)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.Port != 0 {
			n += 1 + sovProtomsg(uint64(m.Port))
			}
			l = len(m.Username)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Password)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Brand)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Reserved)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			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
			}
			var l int
			_ = l
			l = len(m.Taskid)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Taskname)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.CreateAt)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.CreateBy)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.UpdateAt)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.Enable {
			n += 2
			}
			if m.IsAlarm {
			n += 2
			}
			if m.DelFlag {
			n += 2
			}
			return n
			}

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

			func (m *CameraTask) 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.CameraIds)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.TaskId)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if len(m.TimeRule) > 0 {
			for _, e := range m.TimeRule {
			l = e.Size()
			n += 1 + l + sovProtomsg(uint64(l))
			}
			}
			l = len(m.ReactRule)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.ReactDevice)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.DelFlag {
			n += 2
			}
			if m.UpdateFlag {
			n += 2
			}
			if m.Enable {
			n += 2
			}
			if m.Sort != 0 {
			n += 1 + sovProtomsg(uint64(m.Sort))
			}
			if m.IsFull {
			n += 2
			}
			l = len(m.LinkGroupId)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			return n
			}

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

			func (m *TimeRange) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Start)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.End)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			return n
			}

			func (m *Polygon) 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))
			}
			if len(m.Points) > 0 {
			for _, e := range m.Points {
			l = e.Size()
			n += 1 + l + sovProtomsg(uint64(l))
			}
			}
			return n
			}

			func (m *CameraTaskArgs) 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.CameraTaskId)
			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.PolygonId)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.SdkId)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.SdkArgAlias)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Operator)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.OperatorType)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.SdkArgValue)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.Sort != 0 {
			n += 1 + sovProtomsg(uint64(m.Sort))
			}
			l = len(m.RuleWithNext)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.GroupId)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			return n
			}

			func (m *Sdk) 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.SdkType)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.SdkName)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if len(m.Args) > 0 {
			for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovProtomsg(uint64(l))
			}
			}
			l = len(m.Icon)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Url)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.CreateTime)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.UpdateTime)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.CreateBy)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Enabled)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.DelFlag)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			return n
			}

			func (m *SdkArg) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Alias)
			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.Type)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.Must {
			n += 2
			}
			l = len(m.Range)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			if m.Sort != 0 {
			n += 1 + sovProtomsg(uint64(m.Sort))
			}
			return n
			}
			@@ -1531,6 +3992,40 @@
			}
			if m.Prob != 0 {
			n += 5
			}
			return n
			}

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

			func (m *ParamFaceCompare) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Feat1)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			l = len(m.Feat2)
			if l > 0 {
			n += 1 + l + sovProtomsg(uint64(l))
			}
			return n
			}
			@@ -1940,6 +4435,2871 @@
			m.Data = []byte{}
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *Area) 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: Area: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: Area: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Id \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 2:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Parentid", wireType)
			}
			m.Parentid = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Parentid \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			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
			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 *Camera) 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: Camera: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: Camera: 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 != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Type \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Addr", 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.Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Areaid", wireType)
			}
			m.Areaid = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Areaid \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			if wireType != 5 {
			return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
			return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Longitude = float32(math.Float32frombits(v))
			case 7:
			if wireType != 5 {
			return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
			return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Latitude = float32(math.Float32frombits(v))
			case 8:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Rtsp", 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.Rtsp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 9:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Ip", 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.Ip = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 10:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Port \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 11:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Username", 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.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 12:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Password", 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.Password = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 13:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Brand", 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.Brand = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 14:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Reserved", 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.Reserved = 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 *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
			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: Task: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: Task: 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 Taskname", 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.Taskname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", 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.CreateAt = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field CreateBy", 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.CreateBy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field UpdateAt", 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.UpdateAt = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 6:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.Enable = bool(v != 0)
			case 7:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field IsAlarm", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.IsAlarm = bool(v != 0)
			case 8:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.DelFlag = bool(v != 0)
			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 *TaskSdkInfo) 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: TaskSdkInfo: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskSdkInfo: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Task", 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.Task == nil {
			m.Task = &Task{}
			}
			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Sdks", 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.Sdks = append(m.Sdks, &Sdk{})
			if err := m.Sdks[len(m.Sdks)-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 *CameraTask) 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: CameraTask: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: CameraTask: 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 CameraIds", 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.CameraIds = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			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 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field TimeRule", 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.TimeRule = append(m.TimeRule, &DayCtl{})
			if err := m.TimeRule[len(m.TimeRule)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field ReactRule", 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.ReactRule = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field ReactDevice", 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.ReactDevice = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 7:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.DelFlag = bool(v != 0)
			case 8:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field UpdateFlag", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.UpdateFlag = bool(v != 0)
			case 9:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.Enable = bool(v != 0)
			case 10:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			m.Sort = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Sort \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 11:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field IsFull", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.IsFull = bool(v != 0)
			case 12:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field LinkGroupId", 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.LinkGroupId = 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
			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: DayCtl: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: DayCtl: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Day", wireType)
			}
			m.Day = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Day \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field TimeRange", 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.TimeRange = append(m.TimeRange, &TimeRange{})
			if err := m.TimeRange[len(m.TimeRange)-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 *TimeRange) 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: TimeRange: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: TimeRange: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Start", 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.Start = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field End", 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.End = 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 *Polygon) 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: Polygon: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: Polygon: 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 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Points", 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.Points = append(m.Points, &Point{})
			if err := m.Points[len(m.Points)-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 *CameraTaskArgs) 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: CameraTaskArgs: wiretype end group for non-group")
			}
			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 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 CameraTaskId", 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.CameraTaskId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			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 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field PolygonId", 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.PolygonId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return 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.SdkId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkArgAlias", 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.SdkArgAlias = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 7:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Operator", 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.Operator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 8:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field OperatorType", 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.OperatorType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 9:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkArgValue", 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.SdkArgValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 10:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			m.Sort = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Sort \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 11:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RuleWithNext", 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.RuleWithNext = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 12:
			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
			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 *Sdk) 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: Sdk: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: Sdk: 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 SdkType", 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.SdkType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SdkName", 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.SdkName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Args", 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.Args = append(m.Args, &SdkArg{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Icon", 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.Icon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Url", 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.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 7:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", 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.CreateTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 8:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", 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.UpdateTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 9:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field CreateBy", 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.CreateBy = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 10:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Enabled", 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.Enabled = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 11:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", 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.DelFlag = 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 *SdkArg) 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: SdkArg: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: SdkArg: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Alias", 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.Alias = 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 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 5:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Must", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.Must = bool(v != 0)
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Range", 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.Range = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 7:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			m.Sort = 0
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Sort \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			@@ -3235,6 +8595,252 @@
			}
			return nil
			}
			func (m *ParamFacePos) Unmarshal(dAtA []byte) error {
			l := len(dAtA)
			iNdEx := 0
			for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire \|= uint64(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
			return fmt.Errorf("proto: ParamFacePos: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: ParamFacePos: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
			m.Pos = &FacePos{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Img", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowProtomsg
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthProtomsg
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthProtomsg
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.Img == nil {
			m.Img = &Image{}
			}
			if err := m.Img.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipProtomsg(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthProtomsg
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
			}
			}

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

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