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,14 +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"`
   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"`
   GroupId     string        `protobuf:"bytes,7,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   Sort        int32         `protobuf:"varint,8,opt,name=sort,proto3" json:"sort,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{} }
@@ -1300,6 +1326,13 @@
      return m.RuleWithPre
   }
   return ""
}

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

func (m *Rule) GetGroupId() string {
@@ -1521,10 +1554,11 @@
}

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"`
   SdkArgValue string `protobuf:"bytes,3,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort        string `protobuf:"bytes,4,opt,name=sort,proto3" json:"sort,omitempty"`
   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{} }
@@ -1574,6 +1608,13 @@
   return ""
}

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

func (m *SdkSetBase) GetSdkArgValue() string {
   if m != nil {
      return m.SdkArgValue
@@ -1581,11 +1622,11 @@
   return ""
}

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

//Sdk struct
@@ -1606,6 +1647,7 @@
   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{} }
@@ -1749,6 +1791,13 @@
func (m *Sdk) GetArgDef() string {
   if m != nil {
      return m.ArgDef
   }
   return ""
}

func (m *Sdk) GetRuleSo() string {
   if m != nil {
      return m.RuleSo
   }
   return ""
}
@@ -2008,6 +2057,7 @@
   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{} }
@@ -2097,6 +2147,13 @@
      return m.DefenceState
   }
   return 0
}

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

type VideotapeInfo struct {
@@ -2309,6 +2366,7 @@
   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{} }
@@ -2433,6 +2491,13 @@
      return m.CompareTarget
   }
   return ""
}

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

type CompareEvent struct {
@@ -3103,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)
@@ -3144,184 +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{
   // 2740 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x4b, 0x6f, 0x1c, 0xc7,
   0xb5, 0x66, 0xcf, 0x7b, 0xce, 0x0c, 0xc9, 0x56, 0x4b, 0x96, 0x5b, 0x92, 0x4d, 0xf3, 0xb6, 0x6d,
   0x5c, 0x99, 0x7e, 0xdc, 0x0b, 0xd9, 0x8b, 0xbb, 0xf2, 0x05, 0x25, 0x4a, 0xc9, 0x00, 0xb2, 0xc2,
   0x34, 0x47, 0xf2, 0x2e, 0x8d, 0xe2, 0x74, 0x71, 0xa6, 0x31, 0x3d, 0xdd, 0xed, 0xaa, 0x6a, 0x5a,
   0x04, 0xb2, 0x4c, 0x00, 0x67, 0x95, 0x20, 0x7f, 0x21, 0x9b, 0xfc, 0x89, 0x24, 0x5e, 0x66, 0xe9,
   0x65, 0x76, 0x09, 0xec, 0x4d, 0x80, 0xc0, 0xc8, 0x5f, 0x08, 0xce, 0xa9, 0xaa, 0x7e, 0x90, 0x92,
   0xad, 0x55, 0xd7, 0xf9, 0xea, 0x74, 0xd5, 0xa9, 0xf3, 0xae, 0x82, 0x9d, 0x42, 0xe4, 0x2a, 0xdf,
   0xc8, 0xe5, 0x47, 0x34, 0xf0, 0x46, 0x96, 0xbe, 0x0d, 0xa7, 0x4c, 0x72, 0x8d, 0x06, 0x8f, 0xa0,
   0x77, 0x28, 0x38, 0xf3, 0x76, 0xa0, 0x93, 0xc4, 0xbe, 0xb3, 0xef, 0xdc, 0xed, 0x87, 0x9d, 0x24,
   0xf6, 0x6e, 0xc3, 0xa8, 0x60, 0x82, 0x67, 0x2a, 0x89, 0xfd, 0x0e, 0xa1, 0x15, 0xed, 0x79, 0xd0,
   0xcb, 0xd8, 0x86, 0xfb, 0xdd, 0x7d, 0xe7, 0xee, 0x38, 0xa4, 0x71, 0xf0, 0xfb, 0x3e, 0x0c, 0x1e,
   0xb0, 0x0d, 0x17, 0xcd, 0xa5, 0xc6, 0xb4, 0x94, 0x65, 0xef, 0xd4, 0xec, 0xde, 0x0d, 0xe8, 0xb3,
   0x34, 0x61, 0xd2, 0xac, 0xa1, 0x09, 0xef, 0xbf, 0x60, 0x2a, 0x33, 0x56, 0xc8, 0x55, 0xae, 0xa2,
   0x52, 0xa4, 0x7e, 0x8f, 0x26, 0x27, 0x16, 0x7b, 0x2a, 0x52, 0x5c, 0x4c, 0x5d, 0x14, 0xdc, 0xef,
   0x93, 0x4c, 0x34, 0x46, 0x8c, 0xc5, 0xb1, 0xf0, 0x07, 0x7a, 0x03, 0x1c, 0x7b, 0x6f, 0xc0, 0x38,
   0xcd, 0xb3, 0x65, 0xa2, 0xca, 0x98, 0xfb, 0xc3, 0x7d, 0xe7, 0x6e, 0x27, 0xac, 0x01, 0x3c, 0x5d,
   0xca, 0x94, 0x9e, 0x1c, 0xd1, 0x64, 0x45, 0xa3, 0x68, 0x67, 0x69, 0x9e, 0x0b, 0x7f, 0x4c, 0x5b,
   0x68, 0x02, 0xf7, 0x10, 0x4a, 0x16, 0x3e, 0xe8, 0x3d, 0x70, 0x4c, 0x07, 0x2d, 0xfc, 0x89, 0x39,
   0x68, 0x81, 0x3c, 0x45, 0x2e, 0x94, 0x3f, 0xd5, 0xb2, 0xe1, 0x18, 0x77, 0x2a, 0x25, 0x17, 0xa4,
   0x80, 0x6d, 0xe2, 0xac, 0x68, 0xad, 0x63, 0x29, 0xbf, 0xcc, 0x45, 0xec, 0xef, 0xe8, 0x39, 0x4b,
   0xa3, 0x14, 0xa7, 0x82, 0x65, 0xb1, 0xbf, 0xab, 0x15, 0x44, 0x04, 0xfe, 0x21, 0xb8, 0xe4, 0xe2,
   0x9c, 0xc7, 0xbe, 0xab, 0xff, 0xb0, 0xb4, 0xf7, 0x26, 0x40, 0x22, 0x23, 0x51, 0x66, 0x59, 0x92,
   0x2d, 0xfd, 0x6b, 0xfb, 0xce, 0xdd, 0x51, 0x38, 0x4e, 0x64, 0xa8, 0x01, 0x9c, 0x16, 0x65, 0x16,
   0xf1, 0x8c, 0x9d, 0xa6, 0xdc, 0xf7, 0xf4, 0xb4, 0x28, 0xb3, 0x87, 0x04, 0x78, 0xb7, 0x60, 0x84,
   0xd3, 0xa4, 0xdb, 0xeb, 0x24, 0xff, 0x50, 0x94, 0xd9, 0x1c, 0xd5, 0x1b, 0xc0, 0x36, 0x4e, 0xd1,
   0x36, 0x22, 0x4a, 0x62, 0xff, 0x86, 0x36, 0x8b, 0x28, 0xb3, 0x13, 0xc2, 0x66, 0xb1, 0xf7, 0x1e,
   0xb8, 0x82, 0xcb, 0x3c, 0x2d, 0x55, 0x92, 0x67, 0xd1, 0x97, 0x49, 0xac, 0x56, 0xfe, 0x6b, 0xb4,
   0xcc, 0x6e, 0x8d, 0x7f, 0x8e, 0xb0, 0xf7, 0x3e, 0x5c, 0x6b, 0xb0, 0xae, 0x78, 0xb2, 0x5c, 0x29,
   0xff, 0x26, 0xf1, 0x36, 0xd6, 0xf8, 0x29, 0xe1, 0x9e, 0x0b, 0xdd, 0xb3, 0x42, 0xfa, 0xaf, 0xd3,
   0x34, 0x0e, 0xbd, 0x03, 0x18, 0x4a, 0x9e, 0xc9, 0x5c, 0x48, 0xdf, 0xdf, 0xef, 0xde, 0x9d, 0xdc,
   0x73, 0x3f, 0xaa, 0x1c, 0xfd, 0x84, 0x26, 0x42, 0xcb, 0x10, 0xfc, 0xd9, 0x81, 0x81, 0xc6, 0x5e,
   0xe4, 0x94, 0x74, 0x56, 0xe3, 0x94, 0xe4, 0x47, 0xda, 0x9e, 0xdd, 0x2b, 0xf6, 0xec, 0xbd, 0xc4,
   0x9e, 0xfd, 0x1f, 0xb0, 0xe7, 0xe0, 0x92, 0x3d, 0xdf, 0x80, 0xb1, 0x5a, 0x09, 0x2e, 0x57, 0x79,
   0x1a, 0x93, 0x3f, 0xf6, 0xc3, 0x1a, 0xf0, 0x6e, 0xc2, 0xc0, 0x18, 0x66, 0x44, 0x86, 0x31, 0x54,
   0xf0, 0x19, 0x80, 0x0e, 0xaa, 0xc7, 0x49, 0xb6, 0x46, 0x13, 0x2e, 0x88, 0x8a, 0x92, 0x58, 0x9a,
   0xb3, 0x8c, 0x35, 0x32, 0x8b, 0xa5, 0xb7, 0x0f, 0xd3, 0x34, 0xc9, 0xd6, 0x91, 0x62, 0x72, 0x1d,
   0x99, 0xb0, 0x1d, 0x87, 0x80, 0xd8, 0x9c, 0xc9, 0xf5, 0x2c, 0x0e, 0xbe, 0x42, 0x7d, 0xc4, 0xeb,
   0xb0, 0xcc, 0xbc, 0xd7, 0x60, 0x90, 0x14, 0x8b, 0xa8, 0xd2, 0x49, 0x3f, 0x29, 0x16, 0xb3, 0x18,
   0xdd, 0x40, 0xc6, 0xeb, 0xa8, 0xa1, 0x9a, 0xa1, 0x8c, 0xd7, 0xe4, 0x06, 0x1f, 0xc0, 0xb5, 0x44,
   0xce, 0x45, 0xb2, 0x5c, 0x72, 0x71, 0xff, 0xe2, 0x58, 0xf0, 0x93, 0x78, 0x4d, 0xca, 0x1a, 0x85,
   0x57, 0x27, 0xbc, 0x3d, 0x80, 0x45, 0x9e, 0x9d, 0x25, 0x31, 0xcf, 0x16, 0xdc, 0x68, 0xb0, 0x81,
   0x04, 0x3f, 0x87, 0x1d, 0x7d, 0xb2, 0x79, 0xb2, 0xe1, 0xa2, 0x4c, 0xf9, 0x2b, 0xa5, 0x8d, 0x3b,
   0x30, 0x56, 0xc9, 0x86, 0x47, 0xf8, 0x83, 0x31, 0xd4, 0x08, 0x81, 0xb0, 0x4c, 0x79, 0xf0, 0x04,
   0x06, 0x47, 0xec, 0xe2, 0x81, 0x4a, 0xd1, 0x6b, 0x62, 0x76, 0x61, 0xb2, 0x19, 0x0e, 0xbd, 0x7b,
   0x00, 0xfa, 0x47, 0x96, 0x2d, 0x71, 0x49, 0x74, 0x9c, 0xeb, 0xb5, 0xe3, 0xa0, 0x10, 0x21, 0x4e,
   0x85, 0xb4, 0x3e, 0x0d, 0x83, 0x8f, 0x61, 0x5c, 0xe1, 0x18, 0x8f, 0x52, 0x31, 0xa1, 0xac, 0xba,
   0x88, 0xc0, 0x8d, 0x78, 0x66, 0x35, 0x8d, 0xc3, 0xe0, 0x19, 0x0c, 0x8f, 0xf3, 0xf4, 0x62, 0x99,
   0x67, 0xaf, 0x74, 0xa0, 0xff, 0x86, 0x41, 0x91, 0x27, 0x99, 0xc2, 0x44, 0x88, 0x32, 0xed, 0xd6,
   0x32, 0x1d, 0x23, 0x1e, 0x9a, 0xe9, 0xe0, 0x0b, 0xeb, 0x09, 0xb3, 0xec, 0x2c, 0xf7, 0xde, 0xa1,
   0x90, 0xd4, 0xd1, 0xf7, 0x04, 0xd7, 0xd4, 0xbb, 0xb4, 0x41, 0x23, 0x40, 0xe7, 0x8a, 0x00, 0x8d,
   0xbc, 0xdd, 0x8a, 0xfb, 0x5e, 0x2b, 0xee, 0x83, 0x2f, 0xac, 0x89, 0x0e, 0xb3, 0x18, 0x15, 0x2c,
   0xbd, 0x4f, 0xac, 0x03, 0xa2, 0x10, 0xb4, 0xe7, 0xe4, 0xde, 0x8d, 0x5a, 0xe2, 0x5a, 0xc0, 0xb0,
   0xc1, 0xe7, 0xbd, 0x07, 0x7d, 0xb4, 0x97, 0xbc, 0xaa, 0xf6, 0x9f, 0x88, 0xbc, 0x2c, 0x70, 0xe9,
   0x50, 0x73, 0x04, 0xdf, 0x77, 0x60, 0x5c, 0x81, 0x18, 0x33, 0x95, 0x77, 0xfb, 0xce, 0x7e, 0xb7,
   0xed, 0xee, 0x97, 0x4f, 0xf7, 0x26, 0xc0, 0x12, 0x7f, 0x8d, 0x14, 0x7f, 0xae, 0xcc, 0x19, 0xc7,
   0x84, 0xcc, 0xf9, 0x73, 0xe5, 0xbd, 0x05, 0x13, 0x96, 0x32, 0xb1, 0x89, 0x52, 0x7e, 0xce, 0x53,
   0xeb, 0x91, 0x04, 0x3d, 0x46, 0xc4, 0x7b, 0xc7, 0x8a, 0xd9, 0x27, 0x31, 0x77, 0x6a, 0x31, 0x1b,
   0x12, 0x52, 0x80, 0x70, 0xa5, 0xf5, 0x35, 0x30, 0x01, 0xc2, 0x15, 0x05, 0xc8, 0x5b, 0x30, 0x51,
   0x7c, 0x53, 0xa4, 0x4c, 0x71, 0x8c, 0xab, 0xa1, 0x0e, 0x3f, 0x0b, 0xcd, 0x62, 0xef, 0x6d, 0xd8,
   0xae, 0x18, 0xc8, 0x83, 0x47, 0xc4, 0x32, 0xb5, 0x20, 0x1d, 0x7a, 0x1f, 0xa6, 0x95, 0x8b, 0xe3,
   0x32, 0x63, 0xb3, 0x8c, 0xf1, 0xf2, 0x19, 0x1d, 0x54, 0x2e, 0x78, 0xc6, 0x23, 0x32, 0xa6, 0x2e,
   0x48, 0x63, 0x42, 0xc8, 0xea, 0x1e, 0xf4, 0x62, 0x2e, 0x17, 0xa6, 0x2e, 0xd1, 0xb8, 0x91, 0x5f,
   0xa6, 0xad, 0xfc, 0xf2, 0x4b, 0xd8, 0xae, 0xd4, 0x7d, 0x12, 0xaf, 0xe5, 0x15, 0x9f, 0x6d, 0xef,
   0xd5, 0xb9, 0xbc, 0xd7, 0x3b, 0xd0, 0x93, 0xf1, 0xda, 0x3a, 0x6f, 0x33, 0x13, 0x53, 0x96, 0x09,
   0x69, 0x16, 0x77, 0x97, 0xf1, 0x1a, 0x8d, 0xd8, 0x23, 0x23, 0x1a, 0x2a, 0xf8, 0x97, 0x03, 0xbd,
   0xf0, 0x45, 0xa1, 0x7f, 0xc7, 0x1a, 0xbe, 0x4e, 0x63, 0x23, 0x6b, 0x78, 0x14, 0xa9, 0xd0, 0x11,
   0x86, 0xb3, 0xc6, 0xce, 0x06, 0x99, 0xc5, 0x98, 0xd8, 0x30, 0x83, 0x25, 0xb1, 0xe9, 0x1e, 0xfa,
   0xb4, 0x99, 0xf7, 0x21, 0x60, 0x22, 0x8b, 0x24, 0x57, 0xc6, 0xbe, 0x37, 0x5a, 0xc2, 0x9e, 0x70,
   0x75, 0x9f, 0x49, 0x4e, 0xa2, 0x9d, 0x70, 0xa5, 0x6b, 0x5e, 0xca, 0xa3, 0x2f, 0x13, 0xb5, 0x8a,
   0x0a, 0x61, 0x6d, 0x3d, 0x41, 0xf0, 0xf3, 0x44, 0xad, 0x8e, 0x05, 0x85, 0x8e, 0x76, 0xb8, 0xca,
   0xd8, 0x43, 0xa2, 0x67, 0x14, 0x69, 0x12, 0x2b, 0xc7, 0x48, 0x57, 0x0e, 0x1c, 0x07, 0xbf, 0x76,
   0x60, 0x8a, 0xa7, 0x9d, 0x1b, 0x6b, 0xbf, 0x52, 0x7e, 0xb0, 0xc6, 0xec, 0x36, 0x8c, 0xe9, 0x42,
   0x57, 0x3d, 0x57, 0xe6, 0x78, 0x38, 0xf4, 0xde, 0x6f, 0xbb, 0xee, 0x6b, 0x8d, 0xc4, 0x66, 0x36,
   0x3b, 0x14, 0x4b, 0x1b, 0x63, 0x9f, 0x82, 0xdb, 0x14, 0xe3, 0x71, 0x22, 0x95, 0x77, 0x00, 0xbd,
   0x34, 0x91, 0x8a, 0x82, 0x6c, 0x72, 0xef, 0x66, 0xdb, 0xf5, 0x2d, 0x67, 0x48, 0x3c, 0xc1, 0xd7,
   0x0e, 0x4c, 0x1a, 0xcb, 0x36, 0x14, 0xee, 0x34, 0x15, 0x1e, 0xc0, 0x36, 0xc2, 0x4c, 0x2c, 0x23,
   0xdd, 0xe9, 0x75, 0x4c, 0x33, 0x17, 0xaf, 0x0f, 0xc5, 0xf2, 0x90, 0xfa, 0xbd, 0xdb, 0x30, 0xca,
   0x0b, 0x2e, 0x98, 0xca, 0x85, 0xcd, 0xe6, 0x96, 0x6e, 0xfe, 0x7f, 0xce, 0xd2, 0x92, 0x57, 0xcd,
   0x20, 0xfd, 0xff, 0x0c, 0xa1, 0x4a, 0xcd, 0xba, 0x10, 0xd3, 0xf8, 0x55, 0x2c, 0x17, 0xfc, 0xca,
   0x01, 0xa8, 0x8d, 0x7e, 0x55, 0x54, 0xe7, 0x87, 0x45, 0xed, 0xfc, 0x98, 0xa8, 0xdd, 0x97, 0x8b,
   0xda, 0xab, 0x45, 0x0d, 0xfe, 0xd8, 0x85, 0x2e, 0xd6, 0xca, 0xcb, 0x8e, 0x50, 0xd7, 0xe6, 0xce,
   0xcb, 0x6a, 0x73, 0xb7, 0x5d, 0x9b, 0xcd, 0x14, 0xb9, 0x4f, 0xaf, 0x9a, 0xb2, 0x21, 0xca, 0xc4,
   0xd2, 0xba, 0x46, 0x3b, 0x44, 0xd1, 0x2b, 0x68, 0x16, 0xc5, 0x4b, 0x16, 0x79, 0x66, 0x5b, 0x68,
   0x1c, 0xa3, 0x9f, 0x61, 0x13, 0xae, 0x5d, 0x1b, 0x87, 0x98, 0xe1, 0x16, 0x82, 0x63, 0xfa, 0xc2,
   0x74, 0x64, 0xd2, 0x17, 0x68, 0x08, 0x4b, 0x25, 0x32, 0x94, 0x45, 0x5c, 0x31, 0x98, 0xdc, 0xa5,
   0x21, 0x62, 0xc0, 0xc8, 0xd6, 0x2b, 0x9c, 0x5e, 0x98, 0xd4, 0x35, 0xd2, 0xc0, 0xfd, 0x8b, 0x46,
   0x96, 0x9a, 0x34, 0xb3, 0x14, 0x9e, 0x2e, 0xe6, 0x69, 0x74, 0x96, 0xb2, 0xa5, 0xe9, 0xad, 0x87,
   0x31, 0x4f, 0x1f, 0xa5, 0x6c, 0x89, 0x66, 0x41, 0x59, 0xef, 0xa7, 0xf9, 0xa9, 0x6d, 0xaf, 0x2d,
   0xed, 0xf9, 0x30, 0x3c, 0xe7, 0x42, 0x26, 0x79, 0x66, 0xba, 0x6b, 0x4b, 0xe2, 0x0c, 0xcf, 0xe6,
   0x82, 0x2d, 0xd6, 0xd4, 0x5e, 0x8f, 0x42, 0x4b, 0xa2, 0x08, 0x4c, 0x2c, 0x8f, 0xf8, 0x99, 0x69,
   0xaf, 0x0d, 0x15, 0xfc, 0x53, 0x77, 0x4e, 0xe8, 0xef, 0xd5, 0xd5, 0xc5, 0x69, 0x5e, 0x5d, 0x5e,
   0x12, 0xbc, 0x0d, 0x63, 0x55, 0x77, 0x95, 0x4d, 0x29, 0xb5, 0x1f, 0x8c, 0x42, 0x1a, 0x23, 0x56,
   0x66, 0x49, 0xe5, 0xc6, 0x38, 0xc6, 0x5d, 0x74, 0xaf, 0xa2, 0x2d, 0xa2, 0x09, 0xac, 0x20, 0x31,
   0x3f, 0x63, 0x65, 0xaa, 0x8c, 0xa7, 0x69, 0xe3, 0x4c, 0x0d, 0xa8, 0x5d, 0xed, 0x3d, 0x70, 0x2d,
   0x53, 0xe5, 0xb2, 0xda, 0x54, 0xbb, 0x06, 0xff, 0x99, 0xf5, 0x5c, 0xeb, 0x95, 0xe3, 0x46, 0x9e,
   0xfa, 0x4a, 0x07, 0xc7, 0x83, 0x15, 0xcb, 0x30, 0x13, 0x36, 0xbd, 0xce, 0xb9, 0xe2, 0x75, 0x8b,
   0x15, 0xcb, 0xa2, 0xac, 0xdc, 0x98, 0x3b, 0xe2, 0x10, 0xe9, 0x27, 0xe5, 0x06, 0x1b, 0x94, 0xba,
   0xd9, 0x9b, 0x65, 0x3a, 0x81, 0xf5, 0xc3, 0x36, 0x88, 0x4d, 0xe2, 0x26, 0xc9, 0x3e, 0xcb, 0xcf,
   0xf9, 0x71, 0x2e, 0x6d, 0x49, 0xae, 0x91, 0xe0, 0xb7, 0x0e, 0xec, 0x1e, 0x9d, 0xa2, 0x24, 0x4b,
   0xfe, 0x19, 0x97, 0x92, 0x2d, 0xb1, 0x0d, 0xed, 0x2b, 0xf2, 0x11, 0x14, 0x66, 0xa7, 0x99, 0xab,
   0xe6, 0x08, 0x6b, 0xe6, 0x38, 0xd4, 0x4c, 0x57, 0x9a, 0x84, 0x03, 0x18, 0xb0, 0x05, 0xde, 0x2f,
   0x48, 0xa0, 0x9d, 0x7b, 0x5e, 0xfd, 0xfb, 0xd1, 0xe9, 0x21, 0xcd, 0x84, 0x86, 0x83, 0x62, 0x02,
   0xfb, 0x1c, 0x13, 0xb2, 0x38, 0x0e, 0xbe, 0x77, 0x60, 0x5b, 0xb7, 0x39, 0x2f, 0xeb, 0xf2, 0x7e,
   0xb0, 0x76, 0xbd, 0xa8, 0x03, 0xf3, 0x61, 0x68, 0xaa, 0x97, 0x0d, 0x5d, 0x43, 0xe2, 0x75, 0x58,
   0xe9, 0xb6, 0x3a, 0x4a, 0x93, 0xcc, 0xde, 0x37, 0x26, 0x06, 0x7b, 0x9c, 0x64, 0xdc, 0x7b, 0x17,
   0x76, 0xe2, 0x44, 0x70, 0x12, 0x58, 0x33, 0x69, 0x7f, 0xd9, 0xae, 0x50, 0x62, 0xb3, 0x9e, 0x38,
   0x6c, 0x78, 0xa2, 0xf6, 0x25, 0x34, 0x45, 0x24, 0x15, 0x53, 0xdc, 0x14, 0xab, 0xa9, 0x01, 0x4f,
   0x10, 0x0b, 0xfe, 0xe4, 0xc0, 0xf6, 0xb3, 0x24, 0xe6, 0xb9, 0x62, 0x05, 0xa7, 0x6e, 0xee, 0x36,
   0x8c, 0xb8, 0x3c, 0x62, 0x8a, 0xcd, 0xec, 0xa9, 0x2b, 0x1a, 0xe7, 0xec, 0x51, 0xaf, 0x1c, 0xfd,
   0x26, 0x0c, 0x14, 0xdd, 0x42, 0xcc, 0xe1, 0x0d, 0x85, 0x8e, 0x9e, 0x6c, 0x96, 0x33, 0x5d, 0xae,
   0xbb, 0xa1, 0x26, 0x70, 0xa5, 0x73, 0xdc, 0xf6, 0xa9, 0x48, 0xed, 0x35, 0xcb, 0xd2, 0x8d, 0x76,
   0x62, 0xd0, 0x6c, 0x27, 0x5a, 0x87, 0x34, 0x4f, 0x03, 0xc1, 0xff, 0x43, 0xff, 0x59, 0x9e, 0x2c,
   0x5e, 0xb9, 0xd8, 0x16, 0x4c, 0xad, 0xac, 0x75, 0x70, 0x1c, 0xfc, 0x2f, 0x8c, 0x69, 0x01, 0x2a,
   0x93, 0x6f, 0xb7, 0xca, 0x64, 0xa3, 0x57, 0x27, 0x16, 0x53, 0x1f, 0xff, 0xd0, 0x85, 0xc9, 0x83,
   0x7c, 0x53, 0x30, 0x81, 0xe5, 0x91, 0x2a, 0x07, 0xf9, 0x62, 0xdd, 0xc4, 0x56, 0xb4, 0x77, 0x00,
   0xee, 0x42, 0xb3, 0xce, 0xab, 0xcb, 0x61, 0x87, 0xde, 0x23, 0xae, 0xe0, 0xde, 0x3e, 0x4c, 0xce,
   0xd8, 0x82, 0x3f, 0xe2, 0x4c, 0x95, 0x42, 0xbb, 0xd0, 0x34, 0x6c, 0x42, 0xa8, 0x4a, 0x54, 0xaa,
   0x6d, 0xb3, 0x34, 0x41, 0x37, 0x4f, 0xc1, 0xf9, 0x93, 0x3c, 0x36, 0x0d, 0xc2, 0x38, 0xac, 0x01,
   0x52, 0x1a, 0x3b, 0xb5, 0xaa, 0xa4, 0x31, 0x86, 0x65, 0xdd, 0x17, 0xdb, 0x3e, 0xb6, 0xd1, 0x29,
   0xef, 0x01, 0x48, 0xce, 0xc4, 0x62, 0x35, 0xd7, 0x55, 0x00, 0xff, 0x6c, 0x20, 0x38, 0x9f, 0x64,
   0x45, 0xa9, 0xd3, 0x91, 0x2d, 0x02, 0x35, 0xa2, 0xef, 0x86, 0x69, 0xaa, 0xfd, 0xd3, 0x54, 0x81,
   0x06, 0x42, 0x06, 0xce, 0x4b, 0xb1, 0xa8, 0xea, 0x80, 0xa6, 0x30, 0xa9, 0xb0, 0x8c, 0xa5, 0x17,
   0xf6, 0xd5, 0x81, 0x8a, 0xc1, 0x38, 0x6c, 0x83, 0x3a, 0xf5, 0x68, 0xdd, 0x31, 0xb1, 0xe4, 0xca,
   0xd4, 0x85, 0x36, 0x18, 0x9c, 0xc2, 0xd4, 0x18, 0xe9, 0xe1, 0x39, 0xcf, 0x94, 0xf7, 0x7f, 0x30,
   0xe6, 0x38, 0x98, 0xdb, 0x3c, 0xb7, 0x73, 0xef, 0x76, 0xe3, 0x66, 0xd3, 0x60, 0x45, 0x8e, 0xb0,
   0x66, 0xa6, 0xf8, 0x65, 0x17, 0x69, 0xce, 0xb4, 0xe9, 0xa6, 0xa1, 0x25, 0x83, 0x5f, 0xc0, 0x0e,
   0x26, 0x52, 0xf3, 0x2f, 0x5b, 0xac, 0xae, 0x78, 0xa1, 0x0f, 0x43, 0xf2, 0x85, 0x2a, 0x55, 0x58,
   0xd2, 0x0b, 0x60, 0x6a, 0x04, 0x3e, 0x59, 0xe4, 0xc6, 0xdc, 0x9d, 0xb0, 0x85, 0x05, 0x21, 0xb8,
   0xf5, 0xfa, 0x21, 0x97, 0x65, 0xaa, 0xbc, 0x4f, 0xab, 0xd3, 0x6b, 0xc0, 0xf8, 0xaa, 0xdf, 0xaa,
   0xfb, 0x0d, 0x91, 0xc2, 0x36, 0x7b, 0xf0, 0x9b, 0x2e, 0x8c, 0xe9, 0x98, 0xc7, 0xa5, 0x5c, 0xbd,
   0x52, 0xd4, 0xbc, 0x69, 0xae, 0xd6, 0xfa, 0x7a, 0x6c, 0xfa, 0x71, 0x44, 0x4e, 0xe8, 0x8a, 0x7c,
   0x0b, 0xe8, 0x86, 0x1e, 0xe1, 0x3d, 0xd9, 0xe4, 0x37, 0xa4, 0x1f, 0x66, 0x68, 0xa9, 0x9d, 0x44,
   0x46, 0x92, 0xa9, 0x44, 0x9e, 0x5d, 0x44, 0x2c, 0xd5, 0xa1, 0x3e, 0x0a, 0xa7, 0x89, 0x3c, 0xd1,
   0xe0, 0x61, 0x9a, 0x62, 0x42, 0xa5, 0x86, 0x8e, 0xae, 0x75, 0xe6, 0x59, 0x45, 0x50, 0x5b, 0xfa,
   0x5c, 0x35, 0x5a, 0x86, 0x61, 0xab, 0x65, 0xb8, 0x03, 0x63, 0xfd, 0x16, 0x82, 0xe6, 0xd4, 0xc5,
   0x6f, 0x44, 0x0f, 0x21, 0xe6, 0xa2, 0x46, 0x93, 0x31, 0x3f, 0x4f, 0x16, 0x95, 0x83, 0x22, 0x74,
   0x44, 0x88, 0xf7, 0x3f, 0x30, 0x4a, 0x8a, 0xa8, 0xc8, 0x85, 0x92, 0x3e, 0x5c, 0xbe, 0x2d, 0xa0,
   0x62, 0x66, 0xc5, 0x71, 0x2e, 0x54, 0x38, 0x4c, 0xe8, 0x2b, 0xbd, 0x77, 0xa1, 0x57, 0x8a, 0x54,
   0xfa, 0x13, 0x62, 0xbe, 0xd6, 0x66, 0x7e, 0x2a, 0xd2, 0x90, 0xa6, 0xbd, 0x0f, 0x6d, 0x9f, 0x3e,
   0x25, 0xbe, 0xd7, 0x6b, 0xbe, 0x4a, 0xe5, 0xcd, 0xdb, 0xf0, 0xdf, 0x1d, 0xd8, 0x6e, 0x4d, 0xbc,
   0xe8, 0x7a, 0xa6, 0xf2, 0x22, 0x59, 0x34, 0x1f, 0x6c, 0xc6, 0x84, 0xd0, 0x41, 0xef, 0x80, 0x26,
   0xb0, 0x35, 0xad, 0x9e, 0x4b, 0x10, 0xc0, 0x3e, 0xa6, 0xd9, 0xd1, 0xf6, 0x2e, 0x75, 0xb4, 0x6f,
   0xc3, 0xb6, 0x1d, 0x47, 0xd5, 0x73, 0xeb, 0x38, 0x9c, 0x5a, 0x90, 0x56, 0xa7, 0x17, 0xc5, 0x94,
   0x9b, 0x4e, 0x44, 0x5b, 0x86, 0x4c, 0xa5, 0xa3, 0x3c, 0x80, 0x6d, 0x0a, 0x92, 0xa8, 0x28, 0xe5,
   0xaa, 0xbe, 0x23, 0x4d, 0xb8, 0x3d, 0xd1, 0x2c, 0x0e, 0x9e, 0x02, 0xd4, 0xea, 0x44, 0x71, 0xed,
   0x23, 0x63, 0x61, 0x6b, 0x8b, 0x06, 0x66, 0xf5, 0x63, 0x5c, 0xa7, 0xf1, 0x18, 0x57, 0x5b, 0xbf,
   0xdb, 0xba, 0xd6, 0x7e, 0x0c, 0x43, 0xa3, 0x78, 0xdb, 0xc4, 0x3a, 0x75, 0x13, 0x5b, 0xff, 0xd4,
   0x69, 0xfd, 0xf4, 0x17, 0x47, 0x0b, 0x73, 0xa8, 0x14, 0x86, 0xea, 0xeb, 0x30, 0xb4, 0x82, 0xeb,
   0x9f, 0x07, 0x05, 0xc9, 0xec, 0x05, 0xd0, 0x5d, 0x30, 0xdd, 0xf0, 0xb4, 0xfa, 0x69, 0xdd, 0x16,
   0x84, 0x38, 0xd9, 0x3c, 0x89, 0xad, 0x77, 0xf6, 0x24, 0x31, 0xba, 0x9f, 0x99, 0x6c, 0xf4, 0xeb,
   0x20, 0xeb, 0x77, 0x9b, 0x5b, 0x30, 0x4a, 0xf3, 0x05, 0x4b, 0x51, 0x0d, 0x5a, 0xf1, 0x43, 0xa2,
   0x67, 0x05, 0x2e, 0x4c, 0x75, 0x90, 0x9e, 0xc7, 0x07, 0xed, 0xc2, 0x18, 0xfc, 0xdb, 0x81, 0xeb,
   0x0f, 0xe5, 0x31, 0x17, 0x32, 0xcf, 0x1e, 0xb0, 0xc5, 0xca, 0x34, 0x43, 0xde, 0x07, 0xa6, 0x30,
   0xea, 0xb4, 0xd6, 0x48, 0x05, 0x0f, 0x65, 0x83, 0x2d, 0x36, 0x7d, 0xc1, 0x2d, 0x53, 0xaf, 0x74,
   0xff, 0xd2, 0xad, 0x92, 0xd2, 0x8c, 0x7a, 0x9b, 0x82, 0x56, 0x6f, 0x1c, 0x4b, 0x03, 0x33, 0xca,
   0x65, 0x67, 0xa6, 0x36, 0x99, 0x38, 0x37, 0x64, 0xa3, 0xe9, 0xea, 0xff, 0x68, 0xd3, 0x55, 0x5b,
   0x67, 0x40, 0x86, 0xb6, 0x01, 0x7d, 0x03, 0xfa, 0x0b, 0x26, 0x9e, 0xe4, 0xc6, 0x8b, 0x34, 0x71,
   0xf0, 0xb5, 0x03, 0xd3, 0x66, 0xdb, 0xe7, 0x4d, 0x61, 0x34, 0x8f, 0xb4, 0x25, 0xdc, 0x2d, 0xcf,
   0x85, 0xa9, 0xa5, 0x30, 0x7c, 0x5c, 0xc7, 0x1b, 0x43, 0x7f, 0x1e, 0x9d, 0xc4, 0x6b, 0xb7, 0xe3,
   0x5d, 0x87, 0x5d, 0x3b, 0x69, 0x7a, 0x39, 0xb7, 0xeb, 0xed, 0x00, 0xcc, 0xa3, 0xb9, 0x79, 0x6b,
   0x71, 0x7b, 0x7a, 0x3d, 0x5d, 0x5a, 0xdc, 0xbe, 0x5e, 0xef, 0x38, 0x4f, 0xd3, 0x07, 0xd8, 0xc6,
   0x2e, 0xdd, 0x81, 0x07, 0x30, 0x98, 0x47, 0x8f, 0x92, 0x94, 0xbb, 0x43, 0xef, 0x1a, 0x6c, 0xeb,
   0xf1, 0x09, 0x57, 0x2a, 0xc9, 0x96, 0xee, 0x48, 0xff, 0x50, 0x37, 0xd3, 0xee, 0xd8, 0xdb, 0x85,
   0x89, 0x61, 0x52, 0x6c, 0xb1, 0x76, 0xe1, 0xe0, 0x23, 0x18, 0x59, 0x25, 0xe0, 0x6a, 0xb3, 0x4c,
   0x72, 0xa1, 0xdc, 0x2d, 0x1c, 0x3f, 0xa5, 0x7b, 0x93, 0xeb, 0xe0, 0xf8, 0x88, 0xa7, 0x5c, 0x71,
   0xb7, 0x73, 0x70, 0x08, 0xee, 0xe5, 0x6a, 0x84, 0x8b, 0x86, 0x7c, 0x96, 0x25, 0x8a, 0xcc, 0xe9,
   0x6e, 0x21, 0xa0, 0x7f, 0xd6, 0x80, 0xe3, 0x4d, 0x60, 0x68, 0xfe, 0x72, 0x3b, 0x07, 0x9f, 0xc0,
   0x4e, 0xdb, 0xf2, 0xde, 0x36, 0x8c, 0xe7, 0xd1, 0xd1, 0x29, 0xa9, 0xd2, 0xdd, 0xd2, 0xaa, 0x31,
   0xa4, 0x76, 0x27, 0xd7, 0xb9, 0xef, 0xff, 0xf5, 0xdb, 0x3d, 0xe7, 0x9b, 0x6f, 0xf7, 0x9c, 0x7f,
   0x7c, 0xbb, 0xe7, 0xfc, 0xee, 0xbb, 0xbd, 0xad, 0x6f, 0xbe, 0xdb, 0xdb, 0xfa, 0xdb, 0x77, 0x7b,
   0x5b, 0xa7, 0x03, 0x32, 0xe7, 0xc7, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x36, 0xed, 0xbf, 0x24,
   0x72, 0x1a, 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) {
@@ -3541,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
}
@@ -4134,14 +4387,24 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithPre)))
      i += copy(dAtA[i:], m.RuleWithPre)
   }
   if m.IsSaveAnyhow {
      dAtA[i] = 0x38
      i++
      if m.IsSaveAnyhow {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.GroupId) > 0 {
      dAtA[i] = 0x3a
      dAtA[i] = 0x42
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
      i += copy(dAtA[i:], m.GroupId)
   }
   if m.Sort != 0 {
      dAtA[i] = 0x40
      dAtA[i] = 0x48
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
@@ -4313,17 +4576,22 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
      i += copy(dAtA[i:], m.Operator)
   }
   if len(m.SdkArgValue) > 0 {
   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 len(m.Sort) > 0 {
      dAtA[i] = 0x22
   if m.Sort != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Sort)))
      i += copy(dAtA[i:], m.Sort)
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   return i, nil
}
@@ -4453,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
}
@@ -4672,6 +4948,12 @@
      dAtA[i] = 0x40
      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
}
@@ -4950,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
}
@@ -5422,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)
@@ -5542,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
}
@@ -5866,6 +6271,9 @@
   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))
@@ -5969,13 +6377,16 @@
   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))
   }
   l = len(m.Sort)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   if m.Sort != 0 {
      n += 1 + sovProtomsg(uint64(m.Sort))
   }
   return n
}
@@ -6046,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))
   }
@@ -6176,6 +6591,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
}
@@ -6318,6 +6737,9 @@
   l = len(m.CompareTarget)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.IsCompareAll {
      n += 2
   }
   return n
}
@@ -6571,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
}
@@ -7345,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
@@ -9549,6 +10082,26 @@
         m.RuleWithPre = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IsSaveAnyhow", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 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)
         }
@@ -9580,7 +10133,7 @@
         }
         m.GroupId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
         }
@@ -10265,6 +10818,38 @@
         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
@@ -10295,11 +10880,11 @@
         }
         m.SdkArgValue = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
         }
         var stringLen uint64
         m.Sort = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
@@ -10309,24 +10894,11 @@
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            m.Sort |= int32(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.Sort = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
@@ -10856,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
@@ -11766,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:])
@@ -12691,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:])
@@ -14448,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