change picSmUrl to array,add TaskSdkRule

liuxiaolong

2019-07-30 8bcdcb0c7918babbc276c857521c3af3734ad8ca

 protomsg.pb.go

@@ -1494,6 +1494,202 @@
   return 0
}

type TaskSdkRule struct {
   TaskId   string        `protobuf:"bytes,1,opt,name=taskId,proto3" json:"taskId,omitempty"`
   Enable   bool          `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"`
   SdkRules []*SdkRuleSet `protobuf:"bytes,3,rep,name=sdkRules,proto3" json:"sdkRules,omitempty"`
}

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

var xxx_messageInfo_TaskSdkRule proto.InternalMessageInfo

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

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

func (m *TaskSdkRule) GetSdkRules() []*SdkRuleSet {
   if m != nil {
      return m.SdkRules
   }
   return nil
}

type SdkRuleSet struct {
   SdkId string     `protobuf:"bytes,1,opt,name=sdkId,proto3" json:"sdkId,omitempty"`
   IpcId string     `protobuf:"bytes,2,opt,name=ipcId,proto3" json:"ipcId,omitempty"`
   Rules []*SdkRule `protobuf:"bytes,3,rep,name=rules,proto3" json:"rules,omitempty"`
   Sort  int32      `protobuf:"varint,4,opt,name=sort,proto3" json:"sort,omitempty"`
}

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

var xxx_messageInfo_SdkRuleSet proto.InternalMessageInfo

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

func (m *SdkRuleSet) GetIpcId() string {
   if m != nil {
      return m.IpcId
   }
   return ""
}

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

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

type SdkRule struct {
   Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   SdkArgAlias string `protobuf:"bytes,2,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator    string `protobuf:"bytes,3,opt,name=operator,proto3" json:"operator,omitempty"`
   SdkArgValue string `protobuf:"bytes,4,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
}

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

var xxx_messageInfo_SdkRule proto.InternalMessageInfo

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

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

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

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

//SdkArg struct
type SdkArg struct {
   Alias string `protobuf:"bytes,1,opt,name=alias,proto3" json:"alias,omitempty"`
@@ -1509,7 +1705,7 @@
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{17}
   return fileDescriptor_32de24555f916688, []int{20}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1599,7 +1795,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{18}
   return fileDescriptor_32de24555f916688, []int{21}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1671,7 +1867,7 @@
func (m *CameraPolygon) String() string { return proto.CompactTextString(m) }
func (*CameraPolygon) ProtoMessage()    {}
func (*CameraPolygon) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{19}
   return fileDescriptor_32de24555f916688, []int{22}
}
func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1769,7 +1965,7 @@
func (m *VideotapeInfo) String() string { return proto.CompactTextString(m) }
func (*VideotapeInfo) ProtoMessage()    {}
func (*VideotapeInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{20}
   return fileDescriptor_32de24555f916688, []int{23}
}
func (m *VideotapeInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1859,7 +2055,7 @@
func (m *CompareArgs) String() string { return proto.CompactTextString(m) }
func (*CompareArgs) ProtoMessage()    {}
func (*CompareArgs) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{21}
   return fileDescriptor_32de24555f916688, []int{24}
}
func (m *CompareArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1991,7 +2187,7 @@
func (m *EventPush) String() string { return proto.CompactTextString(m) }
func (*EventPush) ProtoMessage()    {}
func (*EventPush) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{22}
   return fileDescriptor_32de24555f916688, []int{25}
}
func (m *EventPush) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2118,7 +2314,7 @@
func (m *EventPushRule) String() string { return proto.CompactTextString(m) }
func (*EventPushRule) ProtoMessage()    {}
func (*EventPushRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{23}
   return fileDescriptor_32de24555f916688, []int{26}
}
func (m *EventPushRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2206,7 +2402,7 @@
func (m *PushIpPort) String() string { return proto.CompactTextString(m) }
func (*PushIpPort) ProtoMessage()    {}
func (*PushIpPort) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{24}
   return fileDescriptor_32de24555f916688, []int{27}
}
func (m *PushIpPort) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2265,7 +2461,7 @@
func (m *PushUrl) String() string { return proto.CompactTextString(m) }
func (*PushUrl) ProtoMessage()    {}
func (*PushUrl) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{25}
   return fileDescriptor_32de24555f916688, []int{28}
}
func (m *PushUrl) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2319,7 +2515,7 @@
func (m *EsPersonCacheChange) String() string { return proto.CompactTextString(m) }
func (*EsPersonCacheChange) ProtoMessage()    {}
func (*EsPersonCacheChange) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{26}
   return fileDescriptor_32de24555f916688, []int{29}
}
func (m *EsPersonCacheChange) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2396,6 +2592,9 @@
   proto.RegisterType((*GroupRule)(nil), "protomsg.GroupRule")
   proto.RegisterType((*Rule)(nil), "protomsg.Rule")
   proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
   proto.RegisterType((*TaskSdkRule)(nil), "protomsg.TaskSdkRule")
   proto.RegisterType((*SdkRuleSet)(nil), "protomsg.SdkRuleSet")
   proto.RegisterType((*SdkRule)(nil), "protomsg.SdkRule")
   proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
   proto.RegisterType((*DbChangeMessage)(nil), "protomsg.DbChangeMessage")
   proto.RegisterType((*CameraPolygon)(nil), "protomsg.CameraPolygon")
@@ -2411,144 +2610,149 @@
func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

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

func (m *Area) Marshal() (dAtA []byte, err error) {
@@ -3548,6 +3752,141 @@
      dAtA[i] = 0x60
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.DelFlag))
   }
   return i, nil
}

func (m *TaskSdkRule) 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 *TaskSdkRule) 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 m.Enable {
      dAtA[i] = 0x10
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.SdkRules) > 0 {
      for _, msg := range m.SdkRules {
         dAtA[i] = 0x1a
         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 *SdkRuleSet) 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 *SdkRuleSet) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.SdkId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkId)))
      i += copy(dAtA[i:], m.SdkId)
   }
   if len(m.IpcId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.IpcId)))
      i += copy(dAtA[i:], m.IpcId)
   }
   if len(m.Rules) > 0 {
      for _, msg := range m.Rules {
         dAtA[i] = 0x1a
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   if m.Sort != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   return i, nil
}

func (m *SdkRule) 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 *SdkRule) 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.SdkArgAlias) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgAlias)))
      i += copy(dAtA[i:], m.SdkArgAlias)
   }
   if len(m.Operator) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
      i += copy(dAtA[i:], m.Operator)
   }
   if len(m.SdkArgValue) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgValue)))
      i += copy(dAtA[i:], m.SdkArgValue)
   }
   return i, nil
}
@@ -4756,6 +5095,79 @@
   }
   if m.DelFlag != 0 {
      n += 1 + sovProtomsg(uint64(m.DelFlag))
   }
   return n
}

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

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

func (m *SdkRule) 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.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.SdkArgValue)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}
@@ -8797,6 +9209,496 @@
   }
   return nil
}
func (m *TaskSdkRule) 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: TaskSdkRule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: TaskSdkRule: 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 != 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 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SdkRules", 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.SdkRules = append(m.SdkRules, &SdkRuleSet{})
         if err := m.SdkRules[len(m.SdkRules)-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 *SdkRuleSet) 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: SdkRuleSet: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkRuleSet: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         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 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field IpcId", 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.IpcId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Rules = append(m.Rules, &SdkRule{})
         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 4:
         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:])
         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 *SdkRule) 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: SdkRule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkRule: 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 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 3:
         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 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 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
      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