TableChanged add T_EventPush

liuxiaolong

2020-09-28 c8c2e1e270b7aa7efe54aef60dae254e416100a7

 protomsg.pb.go

@@ -27,17 +27,20 @@
type TableChanged int32

const (
   TableChanged_T_Camera        TableChanged = 0
   TableChanged_T_CameraRule    TableChanged = 1
   TableChanged_T_Sdk           TableChanged = 2
   TableChanged_T_CameraPolygon TableChanged = 3
   TableChanged_T_TimeRule      TableChanged = 4
   TableChanged_T_Server        TableChanged = 5
   TableChanged_T_PollConfig    TableChanged = 6
   TableChanged_T_File          TableChanged = 7
   TableChanged_T_FileSetting   TableChanged = 8
   TableChanged_T_SdkChanSet    TableChanged = 9
   TableChanged_T_FileStack     TableChanged = 10
   TableChanged_T_Camera           TableChanged = 0
   TableChanged_T_CameraRule       TableChanged = 1
   TableChanged_T_Sdk              TableChanged = 2
   TableChanged_T_CameraPolygon    TableChanged = 3
   TableChanged_T_TimeRule         TableChanged = 4
   TableChanged_T_Server           TableChanged = 5
   TableChanged_T_PollConfig       TableChanged = 6
   TableChanged_T_File             TableChanged = 7
   TableChanged_T_FileSetting      TableChanged = 8
   TableChanged_T_SdkChanSet       TableChanged = 9
   TableChanged_T_FileStack        TableChanged = 10
   TableChanged_T_ResourceConfig   TableChanged = 11
   TableChanged_T_CalculationPower TableChanged = 12
   TableChanged_T_EventPush        TableChanged = 13
)

var TableChanged_name = map[int32]string{
@@ -52,20 +55,26 @@
   8:  "T_FileSetting",
   9:  "T_SdkChanSet",
   10: "T_FileStack",
   11: "T_ResourceConfig",
   12: "T_CalculationPower",
   13: "T_EventPush",
}

var TableChanged_value = map[string]int32{
   "T_Camera":        0,
   "T_CameraRule":    1,
   "T_Sdk":           2,
   "T_CameraPolygon": 3,
   "T_TimeRule":      4,
   "T_Server":        5,
   "T_PollConfig":    6,
   "T_File":          7,
   "T_FileSetting":   8,
   "T_SdkChanSet":    9,
   "T_FileStack":     10,
   "T_Camera":           0,
   "T_CameraRule":       1,
   "T_Sdk":              2,
   "T_CameraPolygon":    3,
   "T_TimeRule":         4,
   "T_Server":           5,
   "T_PollConfig":       6,
   "T_File":             7,
   "T_FileSetting":      8,
   "T_SdkChanSet":       9,
   "T_FileStack":        10,
   "T_ResourceConfig":   11,
   "T_CalculationPower": 12,
   "T_EventPush":        13,
}

func (x TableChanged) String() string {
@@ -244,6 +253,8 @@
   ResolutionHeight int32     `protobuf:"varint,22,opt,name=resolution_height,json=resolutionHeight,proto3" json:"resolution_height,omitempty"`
   Fps              int32     `protobuf:"varint,23,opt,name=fps,proto3" json:"fps,omitempty"`
   Sensors          []*Sensor `protobuf:"bytes,24,rep,name=sensors,proto3" json:"sensors,omitempty"`
   VoiceEnable      bool      `protobuf:"varint,25,opt,name=voiceEnable,proto3" json:"voiceEnable,omitempty"`
   VoiceId          string    `protobuf:"bytes,26,opt,name=voiceId,proto3" json:"voiceId,omitempty"`
}

func (m *Camera) Reset()         { *m = Camera{} }
@@ -445,6 +456,20 @@
      return m.Sensors
   }
   return nil
}

func (m *Camera) GetVoiceEnable() bool {
   if m != nil {
      return m.VoiceEnable
   }
   return false
}

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

type Sensor struct {
@@ -1217,17 +1242,15 @@
}

type Rule struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraId     string `protobuf:"bytes,2,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   PolygonId    string `protobuf:"bytes,3,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
   SdkId        string `protobuf:"bytes,4,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
   SdkArgAlias  string `protobuf:"bytes,5,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator     string `protobuf:"bytes,6,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,7,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   SdkArgValue  string `protobuf:"bytes,8,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort         int32  `protobuf:"varint,9,opt,name=sort,proto3" json:"sort,omitempty"`
   RuleWithPre  string `protobuf:"bytes,10,opt,name=rule_with_pre,json=ruleWithPre,proto3" json:"rule_with_pre,omitempty"`
   GroupId      string `protobuf:"bytes,11,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   Id           string        `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraId     string        `protobuf:"bytes,2,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   PolygonId    string        `protobuf:"bytes,3,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
   SdkId        string        `protobuf:"bytes,4,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
   SdkSet       []*SdkSetBase `protobuf:"bytes,5,rep,name=sdk_set,json=sdkSet,proto3" json:"sdk_set,omitempty"`
   RuleWithPre  string        `protobuf:"bytes,6,opt,name=rule_with_pre,json=ruleWithPre,proto3" json:"rule_with_pre,omitempty"`
   IsSaveAnyhow bool          `protobuf:"varint,7,opt,name=is_save_anyhow,json=isSaveAnyhow,proto3" json:"is_save_anyhow,omitempty"`
   GroupId      string        `protobuf:"bytes,8,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   Sort         int32         `protobuf:"varint,9,opt,name=sort,proto3" json:"sort,omitempty"`
}

func (m *Rule) Reset()         { *m = Rule{} }
@@ -1291,39 +1314,11 @@
   return ""
}

func (m *Rule) GetSdkArgAlias() string {
func (m *Rule) GetSdkSet() []*SdkSetBase {
   if m != nil {
      return m.SdkArgAlias
      return m.SdkSet
   }
   return ""
}

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

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

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

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

func (m *Rule) GetRuleWithPre() string {
@@ -1333,11 +1328,25 @@
   return ""
}

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

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

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

type RuleTemplate struct {
@@ -1544,6 +1553,82 @@
   return ""
}

type SdkSetBase struct {
   SdkArgAlias  string `protobuf:"bytes,1,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator     string `protobuf:"bytes,2,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,3,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   SdkArgValue  string `protobuf:"bytes,4,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort         int32  `protobuf:"varint,5,opt,name=sort,proto3" json:"sort,omitempty"`
}

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

var xxx_messageInfo_SdkSetBase proto.InternalMessageInfo

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

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

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

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

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

//Sdk struct
type Sdk struct {
   Id         string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
@@ -1562,13 +1647,14 @@
   Version    string    `protobuf:"bytes,14,opt,name=version,proto3" json:"version,omitempty"`
   EnTrack    bool      `protobuf:"varint,15,opt,name=enTrack,proto3" json:"enTrack,omitempty"`
   ArgDef     string    `protobuf:"bytes,16,opt,name=argDef,proto3" json:"argDef,omitempty"`
   RuleSo     string    `protobuf:"bytes,17,opt,name=ruleSo,proto3" json:"ruleSo,omitempty"`
}

func (m *Sdk) Reset()         { *m = Sdk{} }
func (m *Sdk) String() string { return proto.CompactTextString(m) }
func (*Sdk) ProtoMessage()    {}
func (*Sdk) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{17}
   return fileDescriptor_32de24555f916688, []int{18}
}
func (m *Sdk) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1709,6 +1795,13 @@
   return ""
}

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

//SdkArg struct
type SdkArg struct {
   Alias           string `protobuf:"bytes,1,opt,name=alias,proto3" json:"alias,omitempty"`
@@ -1726,7 +1819,7 @@
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{18}
   return fileDescriptor_32de24555f916688, []int{19}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1829,7 +1922,7 @@
func (m *SdkChanSet) String() string { return proto.CompactTextString(m) }
func (*SdkChanSet) ProtoMessage()    {}
func (*SdkChanSet) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{19}
   return fileDescriptor_32de24555f916688, []int{20}
}
func (m *SdkChanSet) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1898,7 +1991,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{20}
   return fileDescriptor_32de24555f916688, []int{21}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1964,13 +2057,14 @@
   DirectionLine string `protobuf:"bytes,6,opt,name=direction_line,json=directionLine,proto3" json:"direction_line,omitempty"`
   Type          string `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
   DefenceState  int32  `protobuf:"varint,8,opt,name=defence_state,json=defenceState,proto3" json:"defence_state,omitempty"`
   CameraName    string `protobuf:"bytes,9,opt,name=camera_name,json=cameraName,proto3" json:"camera_name,omitempty"`
}

func (m *CameraPolygon) Reset()         { *m = CameraPolygon{} }
func (m *CameraPolygon) String() string { return proto.CompactTextString(m) }
func (*CameraPolygon) ProtoMessage()    {}
func (*CameraPolygon) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{21}
   return fileDescriptor_32de24555f916688, []int{22}
}
func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2055,6 +2149,13 @@
   return 0
}

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

type VideotapeInfo struct {
   EsDataId string   `protobuf:"bytes,1,opt,name=esDataId,proto3" json:"esDataId,omitempty"`
   CameraId string   `protobuf:"bytes,2,opt,name=cameraId,proto3" json:"cameraId,omitempty"`
@@ -2069,7 +2170,7 @@
func (m *VideotapeInfo) String() string { return proto.CompactTextString(m) }
func (*VideotapeInfo) ProtoMessage()    {}
func (*VideotapeInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{22}
   return fileDescriptor_32de24555f916688, []int{23}
}
func (m *VideotapeInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2147,6 +2248,110 @@
   return 0
}

type Voice struct {
   Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
}

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

var xxx_messageInfo_Voice proto.InternalMessageInfo

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

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

func (m *Voice) GetPath() string {
   if m != nil {
      return m.Path
   }
   return ""
}

type VoiceList struct {
   List []*Voice `protobuf:"bytes,1,rep,name=list,proto3" json:"list,omitempty"`
}

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

var xxx_messageInfo_VoiceList proto.InternalMessageInfo

func (m *VoiceList) GetList() []*Voice {
   if m != nil {
      return m.List
   }
   return nil
}

type CompareArgs struct {
   TableIds         []string `protobuf:"bytes,1,rep,name=tableIds,proto3" json:"tableIds,omitempty"`
   CompareThreshold float32  `protobuf:"fixed32,2,opt,name=compareThreshold,proto3" json:"compareThreshold,omitempty"`
@@ -2161,13 +2366,14 @@
   Source           bool     `protobuf:"varint,11,opt,name=source,proto3" json:"source,omitempty"`
   AnalyServerId    string   `protobuf:"bytes,12,opt,name=analyServerId,proto3" json:"analyServerId,omitempty"`
   CompareTarget    string   `protobuf:"bytes,13,opt,name=compareTarget,proto3" json:"compareTarget,omitempty"`
   IsCompareAll     bool     `protobuf:"varint,14,opt,name=isCompareAll,proto3" json:"isCompareAll,omitempty"`
}

func (m *CompareArgs) Reset()         { *m = CompareArgs{} }
func (m *CompareArgs) String() string { return proto.CompactTextString(m) }
func (*CompareArgs) ProtoMessage()    {}
func (*CompareArgs) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{23}
   return fileDescriptor_32de24555f916688, []int{26}
}
func (m *CompareArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2287,6 +2493,13 @@
   return ""
}

func (m *CompareArgs) GetIsCompareAll() bool {
   if m != nil {
      return m.IsCompareAll
   }
   return false
}

type CompareEvent struct {
   EventType CompareEventType `protobuf:"varint,1,opt,name=eventType,proto3,enum=protomsg.CompareEventType" json:"eventType,omitempty"`
   Payload   []byte           `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
@@ -2296,7 +2509,7 @@
func (m *CompareEvent) String() string { return proto.CompactTextString(m) }
func (*CompareEvent) ProtoMessage()    {}
func (*CompareEvent) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{24}
   return fileDescriptor_32de24555f916688, []int{27}
}
func (m *CompareEvent) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2349,7 +2562,7 @@
func (m *SdkCompareEach) String() string { return proto.CompactTextString(m) }
func (*SdkCompareEach) ProtoMessage()    {}
func (*SdkCompareEach) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{25}
   return fileDescriptor_32de24555f916688, []int{28}
}
func (m *SdkCompareEach) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2407,7 +2620,7 @@
func (m *SdkCompareResult) String() string { return proto.CompactTextString(m) }
func (*SdkCompareResult) ProtoMessage()    {}
func (*SdkCompareResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{26}
   return fileDescriptor_32de24555f916688, []int{29}
}
func (m *SdkCompareResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2462,7 +2675,7 @@
func (m *EventPush) String() string { return proto.CompactTextString(m) }
func (*EventPush) ProtoMessage()    {}
func (*EventPush) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{27}
   return fileDescriptor_32de24555f916688, []int{30}
}
func (m *EventPush) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2589,7 +2802,7 @@
func (m *EventPushRule) String() string { return proto.CompactTextString(m) }
func (*EventPushRule) ProtoMessage()    {}
func (*EventPushRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{28}
   return fileDescriptor_32de24555f916688, []int{31}
}
func (m *EventPushRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2677,7 +2890,7 @@
func (m *PushIpPort) String() string { return proto.CompactTextString(m) }
func (*PushIpPort) ProtoMessage()    {}
func (*PushIpPort) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{29}
   return fileDescriptor_32de24555f916688, []int{32}
}
func (m *PushIpPort) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2736,7 +2949,7 @@
func (m *PushUrl) String() string { return proto.CompactTextString(m) }
func (*PushUrl) ProtoMessage()    {}
func (*PushUrl) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{30}
   return fileDescriptor_32de24555f916688, []int{33}
}
func (m *PushUrl) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2792,7 +3005,7 @@
func (m *PushAttach) String() string { return proto.CompactTextString(m) }
func (*PushAttach) ProtoMessage()    {}
func (*PushAttach) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{31}
   return fileDescriptor_32de24555f916688, []int{34}
}
func (m *PushAttach) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2877,7 +3090,7 @@
func (m *EsPersonCacheChange) String() string { return proto.CompactTextString(m) }
func (*EsPersonCacheChange) ProtoMessage()    {}
func (*EsPersonCacheChange) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{32}
   return fileDescriptor_32de24555f916688, []int{35}
}
func (m *EsPersonCacheChange) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2955,6 +3168,158 @@
   return ""
}

type ClusterAndNodes struct {
   ClusterId   string  `protobuf:"bytes,1,opt,name=clusterId,proto3" json:"clusterId,omitempty"`
   ClusterName string  `protobuf:"bytes,2,opt,name=clusterName,proto3" json:"clusterName,omitempty"`
   Nodes       []*Node `protobuf:"bytes,3,rep,name=nodes,proto3" json:"nodes,omitempty"`
}

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

var xxx_messageInfo_ClusterAndNodes proto.InternalMessageInfo

func (m *ClusterAndNodes) GetClusterId() string {
   if m != nil {
      return m.ClusterId
   }
   return ""
}

func (m *ClusterAndNodes) GetClusterName() string {
   if m != nil {
      return m.ClusterName
   }
   return ""
}

func (m *ClusterAndNodes) GetNodes() []*Node {
   if m != nil {
      return m.Nodes
   }
   return nil
}

type Node struct {
   Id         string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   ClusterId  string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
   NodeName   string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
   NodeId     string `protobuf:"bytes,4,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
   NodeIp     string `protobuf:"bytes,5,opt,name=node_ip,json=nodeIp,proto3" json:"node_ip,omitempty"`
   CreateTime string `protobuf:"bytes,6,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
   IsDelete   bool   `protobuf:"varint,7,opt,name=isDelete,proto3" json:"isDelete,omitempty"`
}

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

var xxx_messageInfo_Node proto.InternalMessageInfo

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

func (m *Node) GetClusterId() string {
   if m != nil {
      return m.ClusterId
   }
   return ""
}

func (m *Node) GetNodeName() string {
   if m != nil {
      return m.NodeName
   }
   return ""
}

func (m *Node) GetNodeId() string {
   if m != nil {
      return m.NodeId
   }
   return ""
}

func (m *Node) GetNodeIp() string {
   if m != nil {
      return m.NodeIp
   }
   return ""
}

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

func (m *Node) GetIsDelete() bool {
   if m != nil {
      return m.IsDelete
   }
   return false
}

func init() {
   proto.RegisterEnum("protomsg.TableChanged", TableChanged_name, TableChanged_value)
   proto.RegisterEnum("protomsg.DbAction", DbAction_name, DbAction_value)
@@ -2977,12 +3342,15 @@
   proto.RegisterType((*RuleTemplate)(nil), "protomsg.RuleTemplate")
   proto.RegisterType((*RuleTemplateList)(nil), "protomsg.RuleTemplateList")
   proto.RegisterType((*TemplateArg)(nil), "protomsg.TemplateArg")
   proto.RegisterType((*SdkSetBase)(nil), "protomsg.SdkSetBase")
   proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
   proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
   proto.RegisterType((*SdkChanSet)(nil), "protomsg.SdkChanSet")
   proto.RegisterType((*DbChangeMessage)(nil), "protomsg.DbChangeMessage")
   proto.RegisterType((*CameraPolygon)(nil), "protomsg.CameraPolygon")
   proto.RegisterType((*VideotapeInfo)(nil), "protomsg.VideotapeInfo")
   proto.RegisterType((*Voice)(nil), "protomsg.Voice")
   proto.RegisterType((*VoiceList)(nil), "protomsg.VoiceList")
   proto.RegisterType((*CompareArgs)(nil), "protomsg.CompareArgs")
   proto.RegisterType((*CompareEvent)(nil), "protomsg.CompareEvent")
   proto.RegisterType((*SdkCompareEach)(nil), "protomsg.SdkCompareEach")
@@ -2993,180 +3361,200 @@
   proto.RegisterType((*PushUrl)(nil), "protomsg.PushUrl")
   proto.RegisterType((*PushAttach)(nil), "protomsg.PushAttach")
   proto.RegisterType((*EsPersonCacheChange)(nil), "protomsg.EsPersonCacheChange")
   proto.RegisterType((*ClusterAndNodes)(nil), "protomsg.ClusterAndNodes")
   proto.RegisterType((*Node)(nil), "protomsg.Node")
}

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

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

func (m *Area) Marshal() (dAtA []byte, err error) {
@@ -3386,6 +3774,26 @@
         }
         i += n
      }
   }
   if m.VoiceEnable {
      dAtA[i] = 0xc8
      i++
      dAtA[i] = 0x1
      i++
      if m.VoiceEnable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.VoiceId) > 0 {
      dAtA[i] = 0xd2
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.VoiceId)))
      i += copy(dAtA[i:], m.VoiceId)
   }
   return i, nil
}
@@ -3961,46 +4369,44 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkId)))
      i += copy(dAtA[i:], m.SdkId)
   }
   if len(m.SdkArgAlias) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgAlias)))
      i += copy(dAtA[i:], m.SdkArgAlias)
   if len(m.SdkSet) > 0 {
      for _, msg := range m.SdkSet {
         dAtA[i] = 0x2a
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   if len(m.Operator) > 0 {
   if len(m.RuleWithPre) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
      i += copy(dAtA[i:], m.Operator)
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithPre)))
      i += copy(dAtA[i:], m.RuleWithPre)
   }
   if len(m.OperatorType) > 0 {
      dAtA[i] = 0x3a
   if m.IsSaveAnyhow {
      dAtA[i] = 0x38
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.OperatorType)))
      i += copy(dAtA[i:], m.OperatorType)
      if m.IsSaveAnyhow {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.SdkArgValue) > 0 {
   if len(m.GroupId) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgValue)))
      i += copy(dAtA[i:], m.SdkArgValue)
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
      i += copy(dAtA[i:], m.GroupId)
   }
   if m.Sort != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   if len(m.RuleWithPre) > 0 {
      dAtA[i] = 0x52
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithPre)))
      i += copy(dAtA[i:], m.RuleWithPre)
   }
   if len(m.GroupId) > 0 {
      dAtA[i] = 0x5a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
      i += copy(dAtA[i:], m.GroupId)
   }
   return i, nil
}
@@ -4143,6 +4549,53 @@
   return i, nil
}

func (m *SdkSetBase) 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 *SdkSetBase) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.SdkArgAlias) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgAlias)))
      i += copy(dAtA[i:], m.SdkArgAlias)
   }
   if len(m.Operator) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
      i += copy(dAtA[i:], m.Operator)
   }
   if len(m.OperatorType) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.OperatorType)))
      i += copy(dAtA[i:], m.OperatorType)
   }
   if len(m.SdkArgValue) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgValue)))
      i += copy(dAtA[i:], m.SdkArgValue)
   }
   if m.Sort != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   return i, nil
}

func (m *Sdk) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -4268,6 +4721,14 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ArgDef)))
      i += copy(dAtA[i:], m.ArgDef)
   }
   if len(m.RuleSo) > 0 {
      dAtA[i] = 0x8a
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleSo)))
      i += copy(dAtA[i:], m.RuleSo)
   }
   return i, nil
}
@@ -4488,6 +4949,12 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.DefenceState))
   }
   if len(m.CameraName) > 0 {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraName)))
      i += copy(dAtA[i:], m.CameraName)
   }
   return i, nil
}

@@ -4554,6 +5021,72 @@
      dAtA[i] = 0x38
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
   }
   return i, nil
}

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

func (m *VoiceList) 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 *VoiceList) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.List) > 0 {
      for _, msg := range m.List {
         dAtA[i] = 0xa
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}
@@ -4699,6 +5232,16 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CompareTarget)))
      i += copy(dAtA[i:], m.CompareTarget)
   }
   if m.IsCompareAll {
      dAtA[i] = 0x70
      i++
      if m.IsCompareAll {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   return i, nil
}
@@ -5171,6 +5714,112 @@
   return i, nil
}

func (m *ClusterAndNodes) 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 *ClusterAndNodes) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ClusterId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ClusterId)))
      i += copy(dAtA[i:], m.ClusterId)
   }
   if len(m.ClusterName) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ClusterName)))
      i += copy(dAtA[i:], m.ClusterName)
   }
   if len(m.Nodes) > 0 {
      for _, msg := range m.Nodes {
         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 *Node) 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 *Node) 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.ClusterId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ClusterId)))
      i += copy(dAtA[i:], m.ClusterId)
   }
   if len(m.NodeName) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.NodeName)))
      i += copy(dAtA[i:], m.NodeName)
   }
   if len(m.NodeId) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.NodeId)))
      i += copy(dAtA[i:], m.NodeId)
   }
   if len(m.NodeIp) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.NodeIp)))
      i += copy(dAtA[i:], m.NodeIp)
   }
   if len(m.CreateTime) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateTime)))
      i += copy(dAtA[i:], m.CreateTime)
   }
   if m.IsDelete {
      dAtA[i] = 0x38
      i++
      if m.IsDelete {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -5291,6 +5940,13 @@
         l = e.Size()
         n += 2 + l + sovProtomsg(uint64(l))
      }
   }
   if m.VoiceEnable {
      n += 3
   }
   l = len(m.VoiceId)
   if l > 0 {
      n += 2 + l + sovProtomsg(uint64(l))
   }
   return n
}
@@ -5605,32 +6261,25 @@
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.SdkArgAlias)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Operator)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.OperatorType)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.SdkArgValue)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Sort != 0 {
      n += 1 + sovProtomsg(uint64(m.Sort))
   if len(m.SdkSet) > 0 {
      for _, e := range m.SdkSet {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   l = len(m.RuleWithPre)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.IsSaveAnyhow {
      n += 2
   }
   l = len(m.GroupId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Sort != 0 {
      n += 1 + sovProtomsg(uint64(m.Sort))
   }
   return n
}
@@ -5714,6 +6363,34 @@
   return n
}

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

func (m *Sdk) Size() (n int) {
   if m == nil {
      return 0
@@ -5780,6 +6457,10 @@
      n += 2
   }
   l = len(m.ArgDef)
   if l > 0 {
      n += 2 + l + sovProtomsg(uint64(l))
   }
   l = len(m.RuleSo)
   if l > 0 {
      n += 2 + l + sovProtomsg(uint64(l))
   }
@@ -5911,6 +6592,10 @@
   if m.DefenceState != 0 {
      n += 1 + sovProtomsg(uint64(m.DefenceState))
   }
   l = len(m.CameraName)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

@@ -5947,6 +6632,42 @@
   }
   if m.Type != 0 {
      n += 1 + sovProtomsg(uint64(m.Type))
   }
   return n
}

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

func (m *VoiceList) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if len(m.List) > 0 {
      for _, e := range m.List {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   return n
}
@@ -6016,6 +6737,9 @@
   l = len(m.CompareTarget)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.IsCompareAll {
      n += 2
   }
   return n
}
@@ -6269,6 +6993,65 @@
   l = len(m.CarNo)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

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

func (m *Node) 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.ClusterId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.NodeName)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.NodeId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.NodeIp)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.CreateTime)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.IsDelete {
      n += 2
   }
   return n
}
@@ -7043,6 +7826,58 @@
         if err := m.Sensors[len(m.Sensors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 25:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field VoiceEnable", 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.VoiceEnable = bool(v != 0)
      case 26:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VoiceId", 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.VoiceId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
@@ -9182,9 +10017,9 @@
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SdkArgAlias", wireType)
            return fmt.Errorf("proto: wrong wireType = %d for field SdkSet", wireType)
         }
         var stringLen uint64
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
@@ -9194,140 +10029,27 @@
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.SdkArgAlias = string(dAtA[iNdEx:postIndex])
         m.SdkSet = append(m.SdkSet, &SdkSetBase{})
         if err := m.SdkSet[len(m.SdkSet)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 6:
         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 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field OperatorType", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.OperatorType = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SdkArgValue", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.SdkArgValue = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
         }
         m.Sort = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Sort |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 10:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", wireType)
         }
@@ -9359,7 +10081,27 @@
         }
         m.RuleWithPre = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 11:
      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 ErrIntOverflowProtomsg
            }
            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)
         }
@@ -9391,6 +10133,25 @@
         }
         m.GroupId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 9:
         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:])
@@ -9962,6 +10723,206 @@
   }
   return nil
}
func (m *SdkSetBase) 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: SdkSetBase: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkSetBase: 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 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 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 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 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 ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.OperatorType = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 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
      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 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 *Sdk) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
@@ -10467,6 +11428,38 @@
            return io.ErrUnexpectedEOF
         }
         m.ArgDef = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 17:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RuleSo", 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.RuleSo = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
@@ -11377,6 +12370,38 @@
               break
            }
         }
      case 9:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraName", 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.CameraName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
@@ -11628,6 +12653,242 @@
               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 *Voice) 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: Voice: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Voice: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Name = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Path", 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.Path = 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 *VoiceList) 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: VoiceList: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: VoiceList: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field List", 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.List = append(m.List, &Voice{})
         if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
@@ -12066,6 +13327,26 @@
         }
         m.CompareTarget = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 14:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IsCompareAll", 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.IsCompareAll = bool(v != 0)
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
@@ -13823,6 +15104,422 @@
   }
   return nil
}
func (m *ClusterAndNodes) 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: ClusterAndNodes: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ClusterAndNodes: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", 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.ClusterId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", 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.ClusterName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Nodes", 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.Nodes = append(m.Nodes, &Node{})
         if err := m.Nodes[len(m.Nodes)-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 *Node) 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: Node: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Node: 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 ClusterId", 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.ClusterId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NodeName", 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.NodeName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NodeId", 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.NodeId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NodeIp", 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.NodeIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CreateTime = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IsDelete", 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.IsDelete = bool(v != 0)
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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