pubsub/protomsg.git

			@@ -8,7 +8,6 @@
			proto "github.com/golang/protobuf/proto"
			io "io"
			math "math"
			math_bits "math/bits"
			)

			// Reference imports to suppress errors if they are not otherwise used.
			@@ -20,7 +19,7 @@
			// is compatible with the proto package it is being compiled against.
			// A compilation error at this line likely means your copy of the
			// proto package needs to be updated.
			const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
			const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

			type TaskBasicInfo struct {
			CamId string `protobuf:"bytes,1,opt,name=CamId,proto3" json:"CamId,omitempty"`
			@@ -51,7 +50,7 @@
			return xxx_messageInfo_TaskBasicInfo.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalToSizedBuffer(b)
			n, err := m.MarshalTo(b)
			if err != nil {
			return nil, err
			}
			@@ -133,6 +132,188 @@
			return ""
			}

			type RuleParams struct {
			SdkArgAlias string `protobuf:"bytes,1,opt,name=SdkArgAlias,proto3" json:"SdkArgAlias,omitempty"`
			Operator string `protobuf:"bytes,2,opt,name=Operator,proto3" json:"Operator,omitempty"`
			OperatorType string `protobuf:"bytes,3,opt,name=OperatorType,proto3" json:"OperatorType,omitempty"`
			SdkArgValue string `protobuf:"bytes,4,opt,name=SdkArgValue,proto3" json:"SdkArgValue,omitempty"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			}

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

			var xxx_messageInfo_RuleParams proto.InternalMessageInfo

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

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

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

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

			type SoRule struct {
			Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
			CameraId string `protobuf:"bytes,2,opt,name=CameraId,proto3" json:"CameraId,omitempty"`
			PolygonId string `protobuf:"bytes,3,opt,name=PolygonId,proto3" json:"PolygonId,omitempty"`
			SdkId string `protobuf:"bytes,4,opt,name=SdkId,proto3" json:"SdkId,omitempty"`
			Sort int32 `protobuf:"varint,5,opt,name=Sort,proto3" json:"Sort,omitempty"`
			RuleWithPre string `protobuf:"bytes,6,opt,name=RuleWithPre,proto3" json:"RuleWithPre,omitempty"`
			IsSaveAnyhow bool `protobuf:"varint,7,opt,name=IsSaveAnyhow,proto3" json:"IsSaveAnyhow,omitempty"`
			GroupId string `protobuf:"bytes,8,opt,name=GroupId,proto3" json:"GroupId,omitempty"`
			Params []*RuleParams `protobuf:"bytes,9,rep,name=Params,proto3" json:"Params,omitempty"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			}

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

			var xxx_messageInfo_SoRule proto.InternalMessageInfo

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

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

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

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

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

			func (m *SoRule) GetRuleWithPre() string {
			if m != nil {
			return m.RuleWithPre
			}
			return ""
			}

			func (m *SoRule) GetIsSaveAnyhow() bool {
			if m != nil {
			return m.IsSaveAnyhow
			}
			return false
			}

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

			func (m SoRule) GetParams() []RuleParams {
			if m != nil {
			return m.Params
			}
			return nil
			}

			type SoTarget struct {
			SrcTarget *Target `protobuf:"bytes,1,opt,name=SrcTarget,proto3" json:"SrcTarget,omitempty"`
			AreaId string `protobuf:"bytes,2,opt,name=AreaId,proto3" json:"AreaId,omitempty"`
			@@ -149,7 +330,7 @@
			func (m *SoTarget) String() string { return proto.CompactTextString(m) }
			func (*SoTarget) ProtoMessage() {}
			func (*SoTarget) Descriptor() ([]byte, []int) {
			return fileDescriptor_02f614a9207041cc, []int{1}
			return fileDescriptor_02f614a9207041cc, []int{3}
			}
			func (m *SoTarget) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -159,7 +340,7 @@
			return xxx_messageInfo_SoTarget.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalToSizedBuffer(b)
			n, err := m.MarshalTo(b)
			if err != nil {
			return nil, err
			}
			@@ -220,6 +401,109 @@
			return 0
			}

			type SoResult struct {
			IsEvent bool `protobuf:"varint,1,opt,name=IsEvent,proto3" json:"IsEvent,omitempty"`
			IsEndRecord bool `protobuf:"varint,2,opt,name=IsEndRecord,proto3" json:"IsEndRecord,omitempty"`
			Targets []*SoTarget `protobuf:"bytes,3,rep,name=Targets,proto3" json:"Targets,omitempty"`
			FirstImage *Image `protobuf:"bytes,4,opt,name=FirstImage,proto3" json:"FirstImage,omitempty"`
			CacheImage *Image `protobuf:"bytes,5,opt,name=CacheImage,proto3" json:"CacheImage,omitempty"`
			SoRule *SoRule `protobuf:"bytes,6,opt,name=soRule,proto3" json:"soRule,omitempty"`
			GroupRule *GroupRule `protobuf:"bytes,7,opt,name=groupRule,proto3" json:"groupRule,omitempty"`
			SoType string `protobuf:"bytes,8,opt,name=SoType,proto3" json:"SoType,omitempty"`
			XXX_NoUnkeyedLiteral struct{} `json:"-"`
			XXX_unrecognized []byte `json:"-"`
			XXX_sizecache int32 `json:"-"`
			}

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

			var xxx_messageInfo_SoResult proto.InternalMessageInfo

			func (m *SoResult) GetIsEvent() bool {
			if m != nil {
			return m.IsEvent
			}
			return false
			}

			func (m *SoResult) GetIsEndRecord() bool {
			if m != nil {
			return m.IsEndRecord
			}
			return false
			}

			func (m SoResult) GetTargets() []SoTarget {
			if m != nil {
			return m.Targets
			}
			return nil
			}

			func (m SoResult) GetFirstImage() Image {
			if m != nil {
			return m.FirstImage
			}
			return nil
			}

			func (m SoResult) GetCacheImage() Image {
			if m != nil {
			return m.CacheImage
			}
			return nil
			}

			func (m SoResult) GetSoRule() SoRule {
			if m != nil {
			return m.SoRule
			}
			return nil
			}

			func (m SoResult) GetGroupRule() GroupRule {
			if m != nil {
			return m.GroupRule
			}
			return nil
			}

			func (m *SoResult) GetSoType() string {
			if m != nil {
			return m.SoType
			}
			return ""
			}

			type EventCache struct {
			Targets map[uint64]*SoTarget `protobuf:"bytes,1,rep,name=Targets,proto3" json:"Targets,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
			RuleGroups map[string]*GroupRule `protobuf:"bytes,2,rep,name=RuleGroups,proto3" json:"RuleGroups,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
			@@ -233,7 +517,7 @@
			func (m *EventCache) String() string { return proto.CompactTextString(m) }
			func (*EventCache) ProtoMessage() {}
			func (*EventCache) Descriptor() ([]byte, []int) {
			return fileDescriptor_02f614a9207041cc, []int{2}
			return fileDescriptor_02f614a9207041cc, []int{5}
			}
			func (m *EventCache) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -243,7 +527,7 @@
			return xxx_messageInfo_EventCache.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalToSizedBuffer(b)
			n, err := m.MarshalTo(b)
			if err != nil {
			return nil, err
			}
			@@ -296,7 +580,7 @@
			func (m *TargetCache) String() string { return proto.CompactTextString(m) }
			func (*TargetCache) ProtoMessage() {}
			func (*TargetCache) Descriptor() ([]byte, []int) {
			return fileDescriptor_02f614a9207041cc, []int{3}
			return fileDescriptor_02f614a9207041cc, []int{6}
			}
			func (m *TargetCache) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -306,7 +590,7 @@
			return xxx_messageInfo_TargetCache.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalToSizedBuffer(b)
			n, err := m.MarshalTo(b)
			if err != nil {
			return nil, err
			}
			@@ -359,7 +643,7 @@
			func (m *FilterResult) String() string { return proto.CompactTextString(m) }
			func (*FilterResult) ProtoMessage() {}
			func (*FilterResult) Descriptor() ([]byte, []int) {
			return fileDescriptor_02f614a9207041cc, []int{4}
			return fileDescriptor_02f614a9207041cc, []int{7}
			}
			func (m *FilterResult) XXX_Unmarshal(b []byte) error {
			return m.Unmarshal(b)
			@@ -369,7 +653,7 @@
			return xxx_messageInfo_FilterResult.Marshal(b, m, deterministic)
			} else {
			b = b[:cap(b)]
			n, err := m.MarshalToSizedBuffer(b)
			n, err := m.MarshalTo(b)
			if err != nil {
			return nil, err
			}
			@@ -411,7 +695,10 @@

			func init() {
			proto.RegisterType((*TaskBasicInfo)(nil), "protomsg.TaskBasicInfo")
			proto.RegisterType((*RuleParams)(nil), "protomsg.RuleParams")
			proto.RegisterType((*SoRule)(nil), "protomsg.SoRule")
			proto.RegisterType((*SoTarget)(nil), "protomsg.SoTarget")
			proto.RegisterType((*SoResult)(nil), "protomsg.SoResult")
			proto.RegisterType((*EventCache)(nil), "protomsg.EventCache")
			proto.RegisterMapType((map[int64]*Image)(nil), "protomsg.EventCache.ImagesEntry")
			proto.RegisterMapType((map[string]*GroupRule)(nil), "protomsg.EventCache.RuleGroupsEntry")
			@@ -426,55 +713,71 @@
			func init() { proto.RegisterFile("dataprocess.proto", fileDescriptor_02f614a9207041cc) }

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

			func (m *TaskBasicInfo) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalToSizedBuffer(dAtA[:size])
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			@@ -482,90 +785,206 @@
			}

			func (m *TaskBasicInfo) MarshalTo(dAtA []byte) (int, error) {
			size := m.Size()
			return m.MarshalToSizedBuffer(dAtA[:size])
			}

			func (m *TaskBasicInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
			i := len(dAtA)
			var i int
			_ = i
			var l int
			_ = l
			if m.XXX_unrecognized != nil {
			i -= len(m.XXX_unrecognized)
			copy(dAtA[i:], m.XXX_unrecognized)
			if len(m.CamId) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamId)))
			i += copy(dAtA[i:], m.CamId)
			}
			if len(m.FileId) > 0 {
			i -= len(m.FileId)
			copy(dAtA[i:], m.FileId)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.FileId)))
			i--
			dAtA[i] = 0x4a
			if len(m.CamName) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamName)))
			i += copy(dAtA[i:], m.CamName)
			}
			if len(m.TaskID) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskID)))
			i += copy(dAtA[i:], m.TaskID)
			}
			if len(m.TaskName) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskName)))
			i += copy(dAtA[i:], m.TaskName)
			}
			if len(m.HandleTime) > 0 {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.HandleTime)))
			i += copy(dAtA[i:], m.HandleTime)
			}
			if m.ImageId != 0 {
			dAtA[i] = 0x30
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
			}
			if len(m.ImageTime) > 0 {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.ImageTime)))
			i += copy(dAtA[i:], m.ImageTime)
			}
			if m.IsEndRecord {
			i--
			dAtA[i] = 0x40
			i++
			if m.IsEndRecord {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x40
			i++
			}
			if len(m.ImageTime) > 0 {
			i -= len(m.ImageTime)
			copy(dAtA[i:], m.ImageTime)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.ImageTime)))
			i--
			dAtA[i] = 0x3a
			if len(m.FileId) > 0 {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.FileId)))
			i += copy(dAtA[i:], m.FileId)
			}
			if m.ImageId != 0 {
			i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
			i--
			dAtA[i] = 0x30
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			if len(m.HandleTime) > 0 {
			i -= len(m.HandleTime)
			copy(dAtA[i:], m.HandleTime)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.HandleTime)))
			i--
			dAtA[i] = 0x2a
			return i, nil
			}

			func (m *RuleParams) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			if len(m.TaskName) > 0 {
			i -= len(m.TaskName)
			copy(dAtA[i:], m.TaskName)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskName)))
			i--
			dAtA[i] = 0x22
			}
			if len(m.TaskID) > 0 {
			i -= len(m.TaskID)
			copy(dAtA[i:], m.TaskID)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskID)))
			i--
			dAtA[i] = 0x1a
			}
			if len(m.CamName) > 0 {
			i -= len(m.CamName)
			copy(dAtA[i:], m.CamName)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamName)))
			i--
			dAtA[i] = 0x12
			}
			if len(m.CamId) > 0 {
			i -= len(m.CamId)
			copy(dAtA[i:], m.CamId)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamId)))
			i--
			return dAtA[:n], nil
			}

			func (m *RuleParams) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.SdkArgAlias) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkArgAlias)))
			i += copy(dAtA[i:], m.SdkArgAlias)
			}
			return len(dAtA) - i, nil
			if len(m.Operator) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.Operator)))
			i += copy(dAtA[i:], m.Operator)
			}
			if len(m.OperatorType) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.OperatorType)))
			i += copy(dAtA[i:], m.OperatorType)
			}
			if len(m.SdkArgValue) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkArgValue)))
			i += copy(dAtA[i:], m.SdkArgValue)
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *SoRule) 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 *SoRule) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if len(m.Id) > 0 {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.Id)))
			i += copy(dAtA[i:], m.Id)
			}
			if len(m.CameraId) > 0 {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CameraId)))
			i += copy(dAtA[i:], m.CameraId)
			}
			if len(m.PolygonId) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.PolygonId)))
			i += copy(dAtA[i:], m.PolygonId)
			}
			if len(m.SdkId) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkId)))
			i += copy(dAtA[i:], m.SdkId)
			}
			if m.Sort != 0 {
			dAtA[i] = 0x28
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.Sort))
			}
			if len(m.RuleWithPre) > 0 {
			dAtA[i] = 0x32
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.RuleWithPre)))
			i += copy(dAtA[i:], m.RuleWithPre)
			}
			if m.IsSaveAnyhow {
			dAtA[i] = 0x38
			i++
			if m.IsSaveAnyhow {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if len(m.GroupId) > 0 {
			dAtA[i] = 0x42
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.GroupId)))
			i += copy(dAtA[i:], m.GroupId)
			}
			if len(m.Params) > 0 {
			for _, msg := range m.Params {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *SoTarget) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalToSizedBuffer(dAtA[:size])
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			@@ -573,78 +992,164 @@
			}

			func (m *SoTarget) MarshalTo(dAtA []byte) (int, error) {
			size := m.Size()
			return m.MarshalToSizedBuffer(dAtA[:size])
			}

			func (m *SoTarget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
			i := len(dAtA)
			var i int
			_ = i
			var l int
			_ = l
			if m.XXX_unrecognized != nil {
			i -= len(m.XXX_unrecognized)
			copy(dAtA[i:], m.XXX_unrecognized)
			}
			if m.ImageId != 0 {
			i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
			i--
			dAtA[i] = 0x30
			}
			if len(m.CompDbInfo) > 0 {
			for iNdEx := len(m.CompDbInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
			size, err := m.CompDbInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
			if m.SrcTarget != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.SrcTarget.Size()))
			n1, err1 := m.SrcTarget.MarshalTo(dAtA[i:])
			if err1 != nil {
			return 0, err1
			}
			}
			if len(m.BelongsTargetID) > 0 {
			i -= len(m.BelongsTargetID)
			copy(dAtA[i:], m.BelongsTargetID)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
			i--
			dAtA[i] = 0x22
			}
			if len(m.AreaName) > 0 {
			i -= len(m.AreaName)
			copy(dAtA[i:], m.AreaName)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
			i--
			dAtA[i] = 0x1a
			i += n1
			}
			if len(m.AreaId) > 0 {
			i -= len(m.AreaId)
			copy(dAtA[i:], m.AreaId)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
			i--
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
			i += copy(dAtA[i:], m.AreaId)
			}
			if m.SrcTarget != nil {
			{
			size, err := m.SrcTarget.MarshalToSizedBuffer(dAtA[:i])
			if len(m.AreaName) > 0 {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
			i += copy(dAtA[i:], m.AreaName)
			}
			if len(m.BelongsTargetID) > 0 {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
			i += copy(dAtA[i:], m.BelongsTargetID)
			}
			if len(m.CompDbInfo) > 0 {
			for _, msg := range m.CompDbInfo {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			i += n
			}
			i--
			dAtA[i] = 0xa
			}
			return len(dAtA) - i, nil
			if m.ImageId != 0 {
			dAtA[i] = 0x30
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *SoResult) 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 *SoResult) MarshalTo(dAtA []byte) (int, error) {
			var i int
			_ = i
			var l int
			_ = l
			if m.IsEvent {
			dAtA[i] = 0x8
			i++
			if m.IsEvent {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if m.IsEndRecord {
			dAtA[i] = 0x10
			i++
			if m.IsEndRecord {
			dAtA[i] = 1
			} else {
			dAtA[i] = 0
			}
			i++
			}
			if len(m.Targets) > 0 {
			for _, msg := range m.Targets {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i += n
			}
			}
			if m.FirstImage != nil {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.FirstImage.Size()))
			n2, err2 := m.FirstImage.MarshalTo(dAtA[i:])
			if err2 != nil {
			return 0, err2
			}
			i += n2
			}
			if m.CacheImage != nil {
			dAtA[i] = 0x2a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.CacheImage.Size()))
			n3, err3 := m.CacheImage.MarshalTo(dAtA[i:])
			if err3 != nil {
			return 0, err3
			}
			i += n3
			}
			if m.SoRule != nil {
			dAtA[i] = 0x32
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size()))
			n4, err4 := m.SoRule.MarshalTo(dAtA[i:])
			if err4 != nil {
			return 0, err4
			}
			i += n4
			}
			if m.GroupRule != nil {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size()))
			n5, err5 := m.GroupRule.MarshalTo(dAtA[i:])
			if err5 != nil {
			return 0, err5
			}
			i += n5
			}
			if len(m.SoType) > 0 {
			dAtA[i] = 0x42
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SoType)))
			i += copy(dAtA[i:], m.SoType)
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *EventCache) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalToSizedBuffer(dAtA[:size])
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			@@ -652,100 +1157,102 @@
			}

			func (m *EventCache) MarshalTo(dAtA []byte) (int, error) {
			size := m.Size()
			return m.MarshalToSizedBuffer(dAtA[:size])
			}

			func (m *EventCache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
			i := len(dAtA)
			var i int
			_ = i
			var l int
			_ = l
			if m.XXX_unrecognized != nil {
			i -= len(m.XXX_unrecognized)
			copy(dAtA[i:], m.XXX_unrecognized)
			}
			if len(m.Images) > 0 {
			for k := range m.Images {
			v := m.Images[k]
			baseI := i
			if len(m.Targets) > 0 {
			for k, _ := range m.Targets {
			dAtA[i] = 0xa
			i++
			v := m.Targets[k]
			msgSize := 0
			if v != nil {
			{
			size, err := v.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			msgSize = v.Size()
			msgSize += 1 + sovDataprocess(uint64(msgSize))
			}
			i = encodeVarintDataprocess(dAtA, i, uint64(k))
			i--
			mapSize := 1 + sovDataprocess(uint64(k)) + msgSize
			i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(k))
			if v != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
			n6, err6 := v.MarshalTo(dAtA[i:])
			if err6 != nil {
			return 0, err6
			}
			i += n6
			}
			}
			}
			if len(m.RuleGroups) > 0 {
			for k := range m.RuleGroups {
			v := m.RuleGroups[k]
			baseI := i
			if v != nil {
			{
			size, err := v.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
			i--
			for k, _ := range m.RuleGroups {
			dAtA[i] = 0x12
			}
			}
			if len(m.Targets) > 0 {
			for k := range m.Targets {
			v := m.Targets[k]
			baseI := i
			i++
			v := m.RuleGroups[k]
			msgSize := 0
			if v != nil {
			{
			size, err := v.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			msgSize = v.Size()
			msgSize += 1 + sovDataprocess(uint64(msgSize))
			}
			i = encodeVarintDataprocess(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
			i--
			mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
			i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
			n7, err7 := v.MarshalTo(dAtA[i:])
			if err7 != nil {
			return 0, err7
			}
			i += n7
			}
			}
			}
			return len(dAtA) - i, nil
			if len(m.Images) > 0 {
			for k, _ := range m.Images {
			dAtA[i] = 0x1a
			i++
			v := m.Images[k]
			msgSize := 0
			if v != nil {
			msgSize = v.Size()
			msgSize += 1 + sovDataprocess(uint64(msgSize))
			}
			mapSize := 1 + sovDataprocess(uint64(k)) + msgSize
			i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(k))
			if v != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
			n8, err8 := v.MarshalTo(dAtA[i:])
			if err8 != nil {
			return 0, err8
			}
			i += n8
			}
			}
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *TargetCache) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalToSizedBuffer(dAtA[:size])
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			@@ -753,78 +1260,70 @@
			}

			func (m *TargetCache) MarshalTo(dAtA []byte) (int, error) {
			size := m.Size()
			return m.MarshalToSizedBuffer(dAtA[:size])
			}

			func (m *TargetCache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
			i := len(dAtA)
			var i int
			_ = i
			var l int
			_ = l
			if m.XXX_unrecognized != nil {
			i -= len(m.XXX_unrecognized)
			copy(dAtA[i:], m.XXX_unrecognized)
			}
			if m.Image != nil {
			{
			size, err := m.Image.MarshalToSizedBuffer(dAtA[:i])
			if len(m.Target) > 0 {
			for _, msg := range m.Target {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			i += n
			}
			i--
			dAtA[i] = 0x1a
			}
			if len(m.RuleGroups) > 0 {
			for k := range m.RuleGroups {
			v := m.RuleGroups[k]
			baseI := i
			if v != nil {
			{
			size, err := v.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
			i--
			for k, _ := range m.RuleGroups {
			dAtA[i] = 0x12
			}
			}
			if len(m.Target) > 0 {
			for iNdEx := len(m.Target) - 1; iNdEx >= 0; iNdEx-- {
			{
			size, err := m.Target[iNdEx].MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			i++
			v := m.RuleGroups[k]
			msgSize := 0
			if v != nil {
			msgSize = v.Size()
			msgSize += 1 + sovDataprocess(uint64(msgSize))
			}
			i--
			mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
			i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
			n9, err9 := v.MarshalTo(dAtA[i:])
			if err9 != nil {
			return 0, err9
			}
			i += n9
			}
			}
			}
			return len(dAtA) - i, nil
			if m.Image != nil {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.Image.Size()))
			n10, err10 := m.Image.MarshalTo(dAtA[i:])
			if err10 != nil {
			return 0, err10
			}
			i += n10
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func (m *FilterResult) Marshal() (dAtA []byte, err error) {
			size := m.Size()
			dAtA = make([]byte, size)
			n, err := m.MarshalToSizedBuffer(dAtA[:size])
			n, err := m.MarshalTo(dAtA)
			if err != nil {
			return nil, err
			}
			@@ -832,96 +1331,90 @@
			}

			func (m *FilterResult) MarshalTo(dAtA []byte) (int, error) {
			size := m.Size()
			return m.MarshalToSizedBuffer(dAtA[:size])
			}

			func (m *FilterResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
			i := len(dAtA)
			var i int
			_ = i
			var l int
			_ = l
			if m.XXX_unrecognized != nil {
			i -= len(m.XXX_unrecognized)
			copy(dAtA[i:], m.XXX_unrecognized)
			}
			if len(m.Targets) > 0 {
			for k := range m.Targets {
			v := m.Targets[k]
			baseI := i
			if v != nil {
			{
			size, err := v.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
			if m.BaseInfo != nil {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(m.BaseInfo.Size()))
			n11, err11 := m.BaseInfo.MarshalTo(dAtA[i:])
			if err11 != nil {
			return 0, err11
			}
			i += n11
			}
			if len(m.Events) > 0 {
			for k := range m.Events {
			v := m.Events[k]
			baseI := i
			if v != nil {
			{
			size, err := v.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i))
			i--
			for k, _ := range m.Events {
			dAtA[i] = 0x12
			}
			}
			if m.BaseInfo != nil {
			{
			size, err := m.BaseInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
			return 0, err
			i++
			v := m.Events[k]
			msgSize := 0
			if v != nil {
			msgSize = v.Size()
			msgSize += 1 + sovDataprocess(uint64(msgSize))
			}
			i -= size
			i = encodeVarintDataprocess(dAtA, i, uint64(size))
			mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
			i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
			n12, err12 := v.MarshalTo(dAtA[i:])
			if err12 != nil {
			return 0, err12
			}
			i += n12
			}
			}
			i--
			dAtA[i] = 0xa
			}
			return len(dAtA) - i, nil
			if len(m.Targets) > 0 {
			for k, _ := range m.Targets {
			dAtA[i] = 0x1a
			i++
			v := m.Targets[k]
			msgSize := 0
			if v != nil {
			msgSize = v.Size()
			msgSize += 1 + sovDataprocess(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize
			i = encodeVarintDataprocess(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
			dAtA[i] = 0x12
			i++
			i = encodeVarintDataprocess(dAtA, i, uint64(v.Size()))
			n13, err13 := v.MarshalTo(dAtA[i:])
			if err13 != nil {
			return 0, err13
			}
			i += n13
			}
			}
			}
			if m.XXX_unrecognized != nil {
			i += copy(dAtA[i:], m.XXX_unrecognized)
			}
			return i, nil
			}

			func encodeVarintDataprocess(dAtA []byte, offset int, v uint64) int {
			offset -= sovDataprocess(v)
			base := offset
			for v >= 1<<7 {
			dAtA[offset] = uint8(v&0x7f \| 0x80)
			v >>= 7
			offset++
			}
			dAtA[offset] = uint8(v)
			return base
			return offset + 1
			}
			func (m *TaskBasicInfo) Size() (n int) {
			if m == nil {
			@@ -969,6 +1462,82 @@
			return n
			}

			func (m *RuleParams) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.SdkArgAlias)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.Operator)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.OperatorType)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.SdkArgValue)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}

			func (m *SoRule) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			l = len(m.Id)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.CameraId)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.PolygonId)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.SdkId)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.Sort != 0 {
			n += 1 + sovDataprocess(uint64(m.Sort))
			}
			l = len(m.RuleWithPre)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.IsSaveAnyhow {
			n += 2
			}
			l = len(m.GroupId)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if len(m.Params) > 0 {
			for _, e := range m.Params {
			l = e.Size()
			n += 1 + l + sovDataprocess(uint64(l))
			}
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}

			func (m *SoTarget) Size() (n int) {
			if m == nil {
			return 0
			@@ -999,6 +1568,50 @@
			}
			if m.ImageId != 0 {
			n += 1 + sovDataprocess(uint64(m.ImageId))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			}
			return n
			}

			func (m *SoResult) Size() (n int) {
			if m == nil {
			return 0
			}
			var l int
			_ = l
			if m.IsEvent {
			n += 2
			}
			if m.IsEndRecord {
			n += 2
			}
			if len(m.Targets) > 0 {
			for _, e := range m.Targets {
			l = e.Size()
			n += 1 + l + sovDataprocess(uint64(l))
			}
			}
			if m.FirstImage != nil {
			l = m.FirstImage.Size()
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.CacheImage != nil {
			l = m.CacheImage.Size()
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.SoRule != nil {
			l = m.SoRule.Size()
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.GroupRule != nil {
			l = m.GroupRule.Size()
			n += 1 + l + sovDataprocess(uint64(l))
			}
			l = len(m.SoType)
			if l > 0 {
			n += 1 + l + sovDataprocess(uint64(l))
			}
			if m.XXX_unrecognized != nil {
			n += len(m.XXX_unrecognized)
			@@ -1135,7 +1748,14 @@
			}

			func sovDataprocess(x uint64) (n int) {
			return (math_bits.Len64(x\|1) + 6) / 7
			for {
			n++
			x >>= 7
			if x == 0 {
			break
			}
			}
			return n
			}
			func sozDataprocess(x uint64) (n int) {
			return sovDataprocess(uint64((x << 1) ^ uint64((int64(x) >> 63))))
			@@ -1438,7 +2058,511 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *RuleParams) 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 ErrIntOverflowDataprocess
			}
			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: RuleParams: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: RuleParams: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkArgAlias = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Operator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.OperatorType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 4:
			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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkArgValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipDataprocess(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *SoRule) 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 ErrIntOverflowDataprocess
			}
			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: SoRule: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: SoRule: 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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 2:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.CameraId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field PolygonId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.PolygonId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 4:
			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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SdkId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 5:
			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 ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			m.Sort \|= int32(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.RuleWithPre = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 7:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field IsSaveAnyhow", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.IsSaveAnyhow = bool(v != 0)
			case 8:
			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 ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.GroupId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			case 9:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Params = append(m.Params, &RuleParams{})
			if err := m.Params[len(m.Params)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipDataprocess(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			@@ -1674,7 +2798,314 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
			}
			}

			if iNdEx > l {
			return io.ErrUnexpectedEOF
			}
			return nil
			}
			func (m *SoResult) 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 ErrIntOverflowDataprocess
			}
			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: SoResult: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
			return fmt.Errorf("proto: SoResult: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field IsEvent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.IsEvent = bool(v != 0)
			case 2:
			if wireType != 0 {
			return fmt.Errorf("proto: wrong wireType = %d for field IsEndRecord", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			v \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			m.IsEndRecord = bool(v != 0)
			case 3:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field Targets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.Targets = append(m.Targets, &SoTarget{})
			if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 4:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field FirstImage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.FirstImage == nil {
			m.FirstImage = &Image{}
			}
			if err := m.FirstImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 5:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field CacheImage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.CacheImage == nil {
			m.CacheImage = &Image{}
			}
			if err := m.CacheImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 6:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SoRule", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.SoRule == nil {
			m.SoRule = &SoRule{}
			}
			if err := m.SoRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 7:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field GroupRule", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			msglen \|= int(b&0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			if msglen < 0 {
			return ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			if m.GroupRule == nil {
			m.GroupRule = &GroupRule{}
			}
			if err := m.GroupRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
			return err
			}
			iNdEx = postIndex
			case 8:
			if wireType != 2 {
			return fmt.Errorf("proto: wrong wireType = %d for field SoType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return ErrIntOverflowDataprocess
			}
			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 ErrInvalidLengthDataprocess
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
			return ErrInvalidLengthDataprocess
			}
			if postIndex > l {
			return io.ErrUnexpectedEOF
			}
			m.SoType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			default:
			iNdEx = preIndex
			skippy, err := skipDataprocess(dAtA[iNdEx:])
			if err != nil {
			return err
			}
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			@@ -1823,7 +3254,7 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > postIndex {
			@@ -1952,7 +3383,7 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > postIndex {
			@@ -2067,7 +3498,7 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > postIndex {
			@@ -2084,7 +3515,10 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			@@ -2281,7 +3715,7 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > postIndex {
			@@ -2334,7 +3768,10 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			@@ -2533,7 +3970,7 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > postIndex {
			@@ -2662,7 +4099,7 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > postIndex {
			@@ -2679,7 +4116,10 @@
			if err != nil {
			return err
			}
			if (skippy < 0) \|\| (iNdEx+skippy) < 0 {
			if skippy < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) < 0 {
			return ErrInvalidLengthDataprocess
			}
			if (iNdEx + skippy) > l {
			@@ -2698,7 +4138,6 @@
			func skipDataprocess(dAtA []byte) (n int, err error) {
			l := len(dAtA)
			iNdEx := 0
			depth := 0
			for iNdEx < l {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
			@@ -2730,8 +4169,10 @@
			break
			}
			}
			return iNdEx, nil
			case 1:
			iNdEx += 8
			return iNdEx, nil
			case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
			@@ -2752,30 +4193,55 @@
			return 0, ErrInvalidLengthDataprocess
			}
			iNdEx += length
			case 3:
			depth++
			case 4:
			if depth == 0 {
			return 0, ErrUnexpectedEndOfGroupDataprocess
			if iNdEx < 0 {
			return 0, ErrInvalidLengthDataprocess
			}
			depth--
			return iNdEx, nil
			case 3:
			for {
			var innerWire uint64
			var start int = iNdEx
			for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
			return 0, ErrIntOverflowDataprocess
			}
			if iNdEx >= l {
			return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			innerWire \|= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
			break
			}
			}
			innerWireType := int(innerWire & 0x7)
			if innerWireType == 4 {
			break
			}
			next, err := skipDataprocess(dAtA[start:])
			if err != nil {
			return 0, err
			}
			iNdEx = start + next
			if iNdEx < 0 {
			return 0, ErrInvalidLengthDataprocess
			}
			}
			return iNdEx, nil
			case 4:
			return iNdEx, nil
			case 5:
			iNdEx += 4
			return iNdEx, nil
			default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
			}
			if iNdEx < 0 {
			return 0, ErrInvalidLengthDataprocess
			}
			if depth == 0 {
			return iNdEx, nil
			}
			}
			return 0, io.ErrUnexpectedEOF
			panic("unreachable")
			}

			var (
			ErrInvalidLengthDataprocess = fmt.Errorf("proto: negative length found during unmarshaling")
			ErrIntOverflowDataprocess = fmt.Errorf("proto: integer overflow")
			ErrUnexpectedEndOfGroupDataprocess = fmt.Errorf("proto: unexpected end of group")
			ErrInvalidLengthDataprocess = fmt.Errorf("proto: negative length found during unmarshaling")
			ErrIntOverflowDataprocess = fmt.Errorf("proto: integer overflow")
			)