add pollChannelCount to PollConfig

liuxiaolong

2019-12-04 abd6d2381b39009f8bd9faf47ddf4535a1596fdc

 protomsg.pb.go

@@ -38,6 +38,8 @@
   TableChanged_T_TimeRule       TableChanged = 8
   TableChanged_T_Server         TableChanged = 9
   TableChanged_T_PollConfig     TableChanged = 10
   TableChanged_T_File           TableChanged = 11
   TableChanged_T_FileSetting    TableChanged = 12
)

var TableChanged_name = map[int32]string{
@@ -52,6 +54,8 @@
   8:  "T_TimeRule",
   9:  "T_Server",
   10: "T_PollConfig",
   11: "T_File",
   12: "T_FileSetting",
}

var TableChanged_value = map[string]int32{
@@ -66,6 +70,8 @@
   "T_TimeRule":       8,
   "T_Server":         9,
   "T_PollConfig":     10,
   "T_File":           11,
   "T_FileSetting":    12,
}

func (x TableChanged) String() string {
@@ -102,6 +108,59 @@

func (DbAction) EnumDescriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{1}
}

type CompareEventType int32

const (
   CompareEventType_ReInitCache CompareEventType = 0
   CompareEventType_UpdateCache CompareEventType = 1
   CompareEventType_Compare     CompareEventType = 2
)

var CompareEventType_name = map[int32]string{
   0: "ReInitCache",
   1: "UpdateCache",
   2: "Compare",
}

var CompareEventType_value = map[string]int32{
   "ReInitCache": 0,
   "UpdateCache": 1,
   "Compare":     2,
}

func (x CompareEventType) String() string {
   return proto.EnumName(CompareEventType_name, int32(x))
}

func (CompareEventType) EnumDescriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{2}
}

type EsCacheChanged int32

const (
   EsCacheChanged_T_DbTable       EsCacheChanged = 0
   EsCacheChanged_T_DbTablePerson EsCacheChanged = 1
)

var EsCacheChanged_name = map[int32]string{
   0: "T_DbTable",
   1: "T_DbTablePerson",
}

var EsCacheChanged_value = map[string]int32{
   "T_DbTable":       0,
   "T_DbTablePerson": 1,
}

func (x EsCacheChanged) String() string {
   return proto.EnumName(EsCacheChanged_name, int32(x))
}

func (EsCacheChanged) EnumDescriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{3}
}

//Area结构体
@@ -173,9 +232,9 @@
   SnapshotUrl string  `protobuf:"bytes,4,opt,name=snapshot_url,json=snapshotUrl,proto3" json:"snapshot_url,omitempty"`
   Type        int32   `protobuf:"varint,5,opt,name=type,proto3" json:"type,omitempty"`
   Addr        string  `protobuf:"bytes,6,opt,name=addr,proto3" json:"addr,omitempty"`
   Areaid      int32   `protobuf:"varint,7,opt,name=areaid,proto3" json:"areaid,omitempty"`
   Longitude   float32 `protobuf:"fixed32,8,opt,name=longitude,proto3" json:"longitude,omitempty"`
   Latitude    float32 `protobuf:"fixed32,9,opt,name=latitude,proto3" json:"latitude,omitempty"`
   Longitude   float32 `protobuf:"fixed32,7,opt,name=longitude,proto3" json:"longitude,omitempty"`
   Latitude    float32 `protobuf:"fixed32,8,opt,name=latitude,proto3" json:"latitude,omitempty"`
   Floor       int32   `protobuf:"varint,9,opt,name=floor,proto3" json:"floor,omitempty"`
   Rtsp        string  `protobuf:"bytes,10,opt,name=rtsp,proto3" json:"rtsp,omitempty"`
   Ip          string  `protobuf:"bytes,11,opt,name=ip,proto3" json:"ip,omitempty"`
   Port        int32   `protobuf:"varint,12,opt,name=port,proto3" json:"port,omitempty"`
@@ -264,13 +323,6 @@
   return ""
}

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

func (m *Camera) GetLongitude() float32 {
   if m != nil {
      return m.Longitude
@@ -281,6 +333,13 @@
func (m *Camera) GetLatitude() float32 {
   if m != nil {
      return m.Latitude
   }
   return 0
}

func (m *Camera) GetFloor() int32 {
   if m != nil {
      return m.Floor
   }
   return 0
}
@@ -1494,22 +1553,220 @@
   return 0
}

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

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

var xxx_messageInfo_TaskSdkRule proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_SdkRuleSet proto.InternalMessageInfo

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

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

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

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

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

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

var xxx_messageInfo_SdkRule proto.InternalMessageInfo

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

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

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

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

//SdkArg struct
type SdkArg struct {
   Alias string `protobuf:"bytes,1,opt,name=alias,proto3" json:"alias,omitempty"`
   Name  string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   Type  string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
   Must  bool   `protobuf:"varint,4,opt,name=must,proto3" json:"must,omitempty"`
   Unit  string `protobuf:"bytes,5,opt,name=unit,proto3" json:"unit,omitempty"`
   Range string `protobuf:"bytes,6,opt,name=range,proto3" json:"range,omitempty"`
   Sort  int32  `protobuf:"varint,7,opt,name=sort,proto3" json:"sort,omitempty"`
   Alias           string `protobuf:"bytes,1,opt,name=alias,proto3" json:"alias,omitempty"`
   Name            string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   Type            string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
   Must            bool   `protobuf:"varint,4,opt,name=must,proto3" json:"must,omitempty"`
   Unit            string `protobuf:"bytes,5,opt,name=unit,proto3" json:"unit,omitempty"`
   Range           string `protobuf:"bytes,6,opt,name=range,proto3" json:"range,omitempty"`
   DefaultValue    string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue,proto3" json:"default_value,omitempty"`
   DefaultOperator string `protobuf:"bytes,8,opt,name=default_operator,json=defaultOperator,proto3" json:"default_operator,omitempty"`
   Sort            int32  `protobuf:"varint,9,opt,name=sort,proto3" json:"sort,omitempty"`
}

func (m *SdkArg) Reset()         { *m = SdkArg{} }
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{17}
   return fileDescriptor_32de24555f916688, []int{20}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1580,6 +1837,20 @@
   return ""
}

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

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

func (m *SdkArg) GetSort() int32 {
   if m != nil {
      return m.Sort
@@ -1599,7 +1870,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{18}
   return fileDescriptor_32de24555f916688, []int{21}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1671,7 +1942,7 @@
func (m *CameraPolygon) String() string { return proto.CompactTextString(m) }
func (*CameraPolygon) ProtoMessage()    {}
func (*CameraPolygon) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{19}
   return fileDescriptor_32de24555f916688, []int{22}
}
func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1756,9 +2027,895 @@
   return 0
}

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"`
   TaskId   string   `protobuf:"bytes,3,opt,name=taskId,proto3" json:"taskId,omitempty"`
   ImgId    int64    `protobuf:"varint,4,opt,name=imgId,proto3" json:"imgId,omitempty"`
   VideoUrl string   `protobuf:"bytes,5,opt,name=videoUrl,proto3" json:"videoUrl,omitempty"`
   SdkIds   []string `protobuf:"bytes,6,rep,name=sdkIds,proto3" json:"sdkIds,omitempty"`
   Type     int32    `protobuf:"varint,7,opt,name=type,proto3" json:"type,omitempty"`
}

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

var xxx_messageInfo_VideotapeInfo proto.InternalMessageInfo

func (m *VideotapeInfo) GetEsDataId() string {
   if m != nil {
      return m.EsDataId
   }
   return ""
}

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

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

func (m *VideotapeInfo) GetImgId() int64 {
   if m != nil {
      return m.ImgId
   }
   return 0
}

func (m *VideotapeInfo) GetVideoUrl() string {
   if m != nil {
      return m.VideoUrl
   }
   return ""
}

func (m *VideotapeInfo) GetSdkIds() []string {
   if m != nil {
      return m.SdkIds
   }
   return nil
}

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

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"`
   FaceFeature      []byte   `protobuf:"bytes,3,opt,name=faceFeature,proto3" json:"faceFeature,omitempty"`
   Tasks            []string `protobuf:"bytes,4,rep,name=tasks,proto3" json:"tasks,omitempty"`
   TreeNodes        []string `protobuf:"bytes,5,rep,name=treeNodes,proto3" json:"treeNodes,omitempty"`
   Tabs             []string `protobuf:"bytes,6,rep,name=tabs,proto3" json:"tabs,omitempty"`
   AlarmLevel       string   `protobuf:"bytes,7,opt,name=alarmLevel,proto3" json:"alarmLevel,omitempty"`
   SearchTime       []string `protobuf:"bytes,8,rep,name=searchTime,proto3" json:"searchTime,omitempty"`
   InputValue       string   `protobuf:"bytes,9,opt,name=inputValue,proto3" json:"inputValue,omitempty"`
   Collection       string   `protobuf:"bytes,10,opt,name=collection,proto3" json:"collection,omitempty"`
   Source           bool     `protobuf:"varint,11,opt,name=source,proto3" json:"source,omitempty"`
   AnalyServerId    string   `protobuf:"bytes,12,opt,name=analyServerId,proto3" json:"analyServerId,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{24}
}
func (m *CompareArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *CompareArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_CompareArgs.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 *CompareArgs) XXX_Merge(src proto.Message) {
   xxx_messageInfo_CompareArgs.Merge(m, src)
}
func (m *CompareArgs) XXX_Size() int {
   return m.Size()
}
func (m *CompareArgs) XXX_DiscardUnknown() {
   xxx_messageInfo_CompareArgs.DiscardUnknown(m)
}

var xxx_messageInfo_CompareArgs proto.InternalMessageInfo

func (m *CompareArgs) GetTableIds() []string {
   if m != nil {
      return m.TableIds
   }
   return nil
}

func (m *CompareArgs) GetCompareThreshold() float32 {
   if m != nil {
      return m.CompareThreshold
   }
   return 0
}

func (m *CompareArgs) GetFaceFeature() []byte {
   if m != nil {
      return m.FaceFeature
   }
   return nil
}

func (m *CompareArgs) GetTasks() []string {
   if m != nil {
      return m.Tasks
   }
   return nil
}

func (m *CompareArgs) GetTreeNodes() []string {
   if m != nil {
      return m.TreeNodes
   }
   return nil
}

func (m *CompareArgs) GetTabs() []string {
   if m != nil {
      return m.Tabs
   }
   return nil
}

func (m *CompareArgs) GetAlarmLevel() string {
   if m != nil {
      return m.AlarmLevel
   }
   return ""
}

func (m *CompareArgs) GetSearchTime() []string {
   if m != nil {
      return m.SearchTime
   }
   return nil
}

func (m *CompareArgs) GetInputValue() string {
   if m != nil {
      return m.InputValue
   }
   return ""
}

func (m *CompareArgs) GetCollection() string {
   if m != nil {
      return m.Collection
   }
   return ""
}

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

func (m *CompareArgs) GetAnalyServerId() string {
   if m != nil {
      return m.AnalyServerId
   }
   return ""
}

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

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

var xxx_messageInfo_CompareEvent proto.InternalMessageInfo

func (m *CompareEvent) GetEventType() CompareEventType {
   if m != nil {
      return m.EventType
   }
   return CompareEventType_ReInitCache
}

func (m *CompareEvent) GetPayload() []byte {
   if m != nil {
      return m.Payload
   }
   return nil
}

type SdkCompareEach struct {
   Id           string  `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Tableid      string  `protobuf:"bytes,2,opt,name=tableid,proto3" json:"tableid,omitempty"`
   CompareScore float32 `protobuf:"fixed32,3,opt,name=compareScore,proto3" json:"compareScore,omitempty"`
}

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

var xxx_messageInfo_SdkCompareEach proto.InternalMessageInfo

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

func (m *SdkCompareEach) GetTableid() string {
   if m != nil {
      return m.Tableid
   }
   return ""
}

func (m *SdkCompareEach) GetCompareScore() float32 {
   if m != nil {
      return m.CompareScore
   }
   return 0
}

type SdkCompareResult struct {
   CompareResult []*SdkCompareEach `protobuf:"bytes,1,rep,name=compareResult,proto3" json:"compareResult,omitempty"`
}

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

var xxx_messageInfo_SdkCompareResult proto.InternalMessageInfo

func (m *SdkCompareResult) GetCompareResult() []*SdkCompareEach {
   if m != nil {
      return m.CompareResult
   }
   return nil
}

type EventPush 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"`
   TimeStart    string           `protobuf:"bytes,3,opt,name=time_start,json=timeStart,proto3" json:"time_start,omitempty"`
   TimeEnd      string           `protobuf:"bytes,4,opt,name=time_end,json=timeEnd,proto3" json:"time_end,omitempty"`
   IsSatisfyAll bool             `protobuf:"varint,5,opt,name=is_satisfy_all,json=isSatisfyAll,proto3" json:"is_satisfy_all,omitempty"`
   RuleText     string           `protobuf:"bytes,6,opt,name=rule_text,json=ruleText,proto3" json:"rule_text,omitempty"`
   Enable       bool             `protobuf:"varint,7,opt,name=enable,proto3" json:"enable,omitempty"`
   LinkType     string           `protobuf:"bytes,8,opt,name=link_type,json=linkType,proto3" json:"link_type,omitempty"`
   LinkDevice   string           `protobuf:"bytes,9,opt,name=link_device,json=linkDevice,proto3" json:"link_device,omitempty"`
   IpPorts      []*PushIpPort    `protobuf:"bytes,10,rep,name=ip_ports,json=ipPorts,proto3" json:"ip_ports,omitempty"`
   Urls         []*PushUrl       `protobuf:"bytes,11,rep,name=urls,proto3" json:"urls,omitempty"`
   Rules        []*EventPushRule `protobuf:"bytes,12,rep,name=rules,proto3" json:"rules,omitempty"`
}

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

var xxx_messageInfo_EventPush proto.InternalMessageInfo

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

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

func (m *EventPush) GetTimeStart() string {
   if m != nil {
      return m.TimeStart
   }
   return ""
}

func (m *EventPush) GetTimeEnd() string {
   if m != nil {
      return m.TimeEnd
   }
   return ""
}

func (m *EventPush) GetIsSatisfyAll() bool {
   if m != nil {
      return m.IsSatisfyAll
   }
   return false
}

func (m *EventPush) GetRuleText() string {
   if m != nil {
      return m.RuleText
   }
   return ""
}

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

func (m *EventPush) GetLinkType() string {
   if m != nil {
      return m.LinkType
   }
   return ""
}

func (m *EventPush) GetLinkDevice() string {
   if m != nil {
      return m.LinkDevice
   }
   return ""
}

func (m *EventPush) GetIpPorts() []*PushIpPort {
   if m != nil {
      return m.IpPorts
   }
   return nil
}

func (m *EventPush) GetUrls() []*PushUrl {
   if m != nil {
      return m.Urls
   }
   return nil
}

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

type EventPushRule struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   TopicType    string `protobuf:"bytes,2,opt,name=topic_type,json=topicType,proto3" json:"topic_type,omitempty"`
   TopicArg     string `protobuf:"bytes,3,opt,name=topic_arg,json=topicArg,proto3" json:"topic_arg,omitempty"`
   Operator     string `protobuf:"bytes,4,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,5,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   RuleValue    string `protobuf:"bytes,6,opt,name=rule_value,json=ruleValue,proto3" json:"rule_value,omitempty"`
   EventPushId  string `protobuf:"bytes,7,opt,name=event_push_id,json=eventPushId,proto3" json:"event_push_id,omitempty"`
}

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

var xxx_messageInfo_EventPushRule proto.InternalMessageInfo

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

func (m *EventPushRule) GetTopicType() string {
   if m != nil {
      return m.TopicType
   }
   return ""
}

func (m *EventPushRule) GetTopicArg() string {
   if m != nil {
      return m.TopicArg
   }
   return ""
}

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

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

func (m *EventPushRule) GetRuleValue() string {
   if m != nil {
      return m.RuleValue
   }
   return ""
}

func (m *EventPushRule) GetEventPushId() string {
   if m != nil {
      return m.EventPushId
   }
   return ""
}

type PushIpPort struct {
   ServerIp string `protobuf:"bytes,1,opt,name=server_ip,json=serverIp,proto3" json:"server_ip,omitempty"`
   Port     int32  `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
   Enable   bool   `protobuf:"varint,3,opt,name=enable,proto3" json:"enable,omitempty"`
}

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

var xxx_messageInfo_PushIpPort proto.InternalMessageInfo

func (m *PushIpPort) GetServerIp() string {
   if m != nil {
      return m.ServerIp
   }
   return ""
}

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

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

type PushUrl struct {
   Url    string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
   Enable bool   `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"`
}

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

var xxx_messageInfo_PushUrl proto.InternalMessageInfo

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

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

type PushAttach struct {
   PushId     string  `protobuf:"bytes,1,opt,name=push_id,json=pushId,proto3" json:"push_id,omitempty"`
   Cam        *Camera `protobuf:"bytes,2,opt,name=cam,proto3" json:"cam,omitempty"`
   ServerId   string  `protobuf:"bytes,3,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   ServerName string  `protobuf:"bytes,4,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
   LocalIp    string  `protobuf:"bytes,5,opt,name=local_ip,json=localIp,proto3" json:"local_ip,omitempty"`
   VideoUrl   string  `protobuf:"bytes,6,opt,name=video_url,json=videoUrl,proto3" json:"video_url,omitempty"`
}

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

var xxx_messageInfo_PushAttach proto.InternalMessageInfo

func (m *PushAttach) GetPushId() string {
   if m != nil {
      return m.PushId
   }
   return ""
}

func (m *PushAttach) GetCam() *Camera {
   if m != nil {
      return m.Cam
   }
   return nil
}

func (m *PushAttach) GetServerId() string {
   if m != nil {
      return m.ServerId
   }
   return ""
}

func (m *PushAttach) GetServerName() string {
   if m != nil {
      return m.ServerName
   }
   return ""
}

func (m *PushAttach) GetLocalIp() string {
   if m != nil {
      return m.LocalIp
   }
   return ""
}

func (m *PushAttach) GetVideoUrl() string {
   if m != nil {
      return m.VideoUrl
   }
   return ""
}

type EsPersonCacheChange struct {
   Type     EsCacheChanged `protobuf:"varint,1,opt,name=type,proto3,enum=protomsg.EsCacheChanged" json:"type,omitempty"`
   TableId  []string       `protobuf:"bytes,2,rep,name=table_id,json=tableId,proto3" json:"table_id,omitempty"`
   PersonId string         `protobuf:"bytes,3,opt,name=person_id,json=personId,proto3" json:"person_id,omitempty"`
   Feature  string         `protobuf:"bytes,4,opt,name=feature,proto3" json:"feature,omitempty"`
   Action   DbAction       `protobuf:"varint,5,opt,name=action,proto3,enum=protomsg.DbAction" json:"action,omitempty"`
   Enable   int32          `protobuf:"varint,6,opt,name=enable,proto3" json:"enable,omitempty"`
}

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

var xxx_messageInfo_EsPersonCacheChange proto.InternalMessageInfo

func (m *EsPersonCacheChange) GetType() EsCacheChanged {
   if m != nil {
      return m.Type
   }
   return EsCacheChanged_T_DbTable
}

func (m *EsPersonCacheChange) GetTableId() []string {
   if m != nil {
      return m.TableId
   }
   return nil
}

func (m *EsPersonCacheChange) GetPersonId() string {
   if m != nil {
      return m.PersonId
   }
   return ""
}

func (m *EsPersonCacheChange) GetFeature() string {
   if m != nil {
      return m.Feature
   }
   return ""
}

func (m *EsPersonCacheChange) GetAction() DbAction {
   if m != nil {
      return m.Action
   }
   return DbAction_Insert
}

func (m *EsPersonCacheChange) GetEnable() int32 {
   if m != nil {
      return m.Enable
   }
   return 0
}

func init() {
   proto.RegisterEnum("protomsg.TableChanged", TableChanged_name, TableChanged_value)
   proto.RegisterEnum("protomsg.DbAction", DbAction_name, DbAction_value)
   proto.RegisterEnum("protomsg.CompareEventType", CompareEventType_name, CompareEventType_value)
   proto.RegisterEnum("protomsg.EsCacheChanged", EsCacheChanged_name, EsCacheChanged_value)
   proto.RegisterType((*Area)(nil), "protomsg.Area")
   proto.RegisterType((*Camera)(nil), "protomsg.Camera")
   proto.RegisterType((*CameraAndTaskInfo)(nil), "protomsg.CameraAndTaskInfo")
@@ -1776,117 +2933,190 @@
   proto.RegisterType((*GroupRule)(nil), "protomsg.GroupRule")
   proto.RegisterType((*Rule)(nil), "protomsg.Rule")
   proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
   proto.RegisterType((*TaskSdkRule)(nil), "protomsg.TaskSdkRule")
   proto.RegisterType((*SdkRuleSet)(nil), "protomsg.SdkRuleSet")
   proto.RegisterType((*SdkRule)(nil), "protomsg.SdkRule")
   proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
   proto.RegisterType((*DbChangeMessage)(nil), "protomsg.DbChangeMessage")
   proto.RegisterType((*CameraPolygon)(nil), "protomsg.CameraPolygon")
   proto.RegisterType((*VideotapeInfo)(nil), "protomsg.VideotapeInfo")
   proto.RegisterType((*CompareArgs)(nil), "protomsg.CompareArgs")
   proto.RegisterType((*CompareEvent)(nil), "protomsg.CompareEvent")
   proto.RegisterType((*SdkCompareEach)(nil), "protomsg.SdkCompareEach")
   proto.RegisterType((*SdkCompareResult)(nil), "protomsg.SdkCompareResult")
   proto.RegisterType((*EventPush)(nil), "protomsg.EventPush")
   proto.RegisterType((*EventPushRule)(nil), "protomsg.EventPushRule")
   proto.RegisterType((*PushIpPort)(nil), "protomsg.PushIpPort")
   proto.RegisterType((*PushUrl)(nil), "protomsg.PushUrl")
   proto.RegisterType((*PushAttach)(nil), "protomsg.PushAttach")
   proto.RegisterType((*EsPersonCacheChange)(nil), "protomsg.EsPersonCacheChange")
}

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

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

func (m *Area) Marshal() (dAtA []byte, err error) {
@@ -1973,22 +3203,22 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Addr)))
      i += copy(dAtA[i:], m.Addr)
   }
   if m.Areaid != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Areaid))
   }
   if m.Longitude != 0 {
      dAtA[i] = 0x45
      dAtA[i] = 0x3d
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Longitude))))
      i += 4
   }
   if m.Latitude != 0 {
      dAtA[i] = 0x4d
      dAtA[i] = 0x45
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Latitude))))
      i += 4
   }
   if m.Floor != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Floor))
   }
   if len(m.Rtsp) > 0 {
      dAtA[i] = 0x52
@@ -2890,6 +4120,141 @@
   return i, nil
}

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

func (m *TaskSdkRule) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.TaskId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TaskId)))
      i += copy(dAtA[i:], m.TaskId)
   }
   if m.Enable {
      dAtA[i] = 0x10
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.SdkRules) > 0 {
      for _, msg := range m.SdkRules {
         dAtA[i] = 0x1a
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

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

func (m *SdkRuleSet) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.SdkId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkId)))
      i += copy(dAtA[i:], m.SdkId)
   }
   if len(m.IpcId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.IpcId)))
      i += copy(dAtA[i:], m.IpcId)
   }
   if len(m.Rules) > 0 {
      for _, msg := range m.Rules {
         dAtA[i] = 0x1a
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   if m.Sort != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   return i, nil
}

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

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

func (m *SdkArg) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -2945,8 +4310,20 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Range)))
      i += copy(dAtA[i:], m.Range)
   }
   if len(m.DefaultValue) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.DefaultValue)))
      i += copy(dAtA[i:], m.DefaultValue)
   }
   if len(m.DefaultOperator) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.DefaultOperator)))
      i += copy(dAtA[i:], m.DefaultOperator)
   }
   if m.Sort != 0 {
      dAtA[i] = 0x38
      dAtA[i] = 0x48
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
@@ -3058,6 +4435,674 @@
   return i, nil
}

func (m *VideotapeInfo) 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 *VideotapeInfo) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.EsDataId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.EsDataId)))
      i += copy(dAtA[i:], m.EsDataId)
   }
   if len(m.CameraId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
      i += copy(dAtA[i:], m.CameraId)
   }
   if len(m.TaskId) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TaskId)))
      i += copy(dAtA[i:], m.TaskId)
   }
   if m.ImgId != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.ImgId))
   }
   if len(m.VideoUrl) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.VideoUrl)))
      i += copy(dAtA[i:], m.VideoUrl)
   }
   if len(m.SdkIds) > 0 {
      for _, s := range m.SdkIds {
         dAtA[i] = 0x32
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if m.Type != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
   }
   return i, nil
}

func (m *CompareArgs) 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 *CompareArgs) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.TableIds) > 0 {
      for _, s := range m.TableIds {
         dAtA[i] = 0xa
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if m.CompareThreshold != 0 {
      dAtA[i] = 0x15
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CompareThreshold))))
      i += 4
   }
   if len(m.FaceFeature) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FaceFeature)))
      i += copy(dAtA[i:], m.FaceFeature)
   }
   if len(m.Tasks) > 0 {
      for _, s := range m.Tasks {
         dAtA[i] = 0x22
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if len(m.TreeNodes) > 0 {
      for _, s := range m.TreeNodes {
         dAtA[i] = 0x2a
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if len(m.Tabs) > 0 {
      for _, s := range m.Tabs {
         dAtA[i] = 0x32
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if len(m.AlarmLevel) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.AlarmLevel)))
      i += copy(dAtA[i:], m.AlarmLevel)
   }
   if len(m.SearchTime) > 0 {
      for _, s := range m.SearchTime {
         dAtA[i] = 0x42
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if len(m.InputValue) > 0 {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.InputValue)))
      i += copy(dAtA[i:], m.InputValue)
   }
   if len(m.Collection) > 0 {
      dAtA[i] = 0x52
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Collection)))
      i += copy(dAtA[i:], m.Collection)
   }
   if m.Source {
      dAtA[i] = 0x58
      i++
      if m.Source {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.AnalyServerId) > 0 {
      dAtA[i] = 0x62
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.AnalyServerId)))
      i += copy(dAtA[i:], m.AnalyServerId)
   }
   return i, nil
}

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

func (m *SdkCompareEach) 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 *SdkCompareEach) 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.Tableid) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Tableid)))
      i += copy(dAtA[i:], m.Tableid)
   }
   if m.CompareScore != 0 {
      dAtA[i] = 0x1d
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CompareScore))))
      i += 4
   }
   return i, nil
}

func (m *SdkCompareResult) 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 *SdkCompareResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.CompareResult) > 0 {
      for _, msg := range m.CompareResult {
         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
}

func (m *EventPush) 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 *EventPush) 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.TimeStart) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeStart)))
      i += copy(dAtA[i:], m.TimeStart)
   }
   if len(m.TimeEnd) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeEnd)))
      i += copy(dAtA[i:], m.TimeEnd)
   }
   if m.IsSatisfyAll {
      dAtA[i] = 0x28
      i++
      if m.IsSatisfyAll {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.RuleText) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleText)))
      i += copy(dAtA[i:], m.RuleText)
   }
   if m.Enable {
      dAtA[i] = 0x38
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.LinkType) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.LinkType)))
      i += copy(dAtA[i:], m.LinkType)
   }
   if len(m.LinkDevice) > 0 {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.LinkDevice)))
      i += copy(dAtA[i:], m.LinkDevice)
   }
   if len(m.IpPorts) > 0 {
      for _, msg := range m.IpPorts {
         dAtA[i] = 0x52
         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.Urls) > 0 {
      for _, msg := range m.Urls {
         dAtA[i] = 0x5a
         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.Rules) > 0 {
      for _, msg := range m.Rules {
         dAtA[i] = 0x62
         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 *EventPushRule) 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 *EventPushRule) 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.TopicType) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TopicType)))
      i += copy(dAtA[i:], m.TopicType)
   }
   if len(m.TopicArg) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TopicArg)))
      i += copy(dAtA[i:], m.TopicArg)
   }
   if len(m.Operator) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
      i += copy(dAtA[i:], m.Operator)
   }
   if len(m.OperatorType) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.OperatorType)))
      i += copy(dAtA[i:], m.OperatorType)
   }
   if len(m.RuleValue) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleValue)))
      i += copy(dAtA[i:], m.RuleValue)
   }
   if len(m.EventPushId) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.EventPushId)))
      i += copy(dAtA[i:], m.EventPushId)
   }
   return i, nil
}

func (m *PushIpPort) 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 *PushIpPort) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ServerIp) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ServerIp)))
      i += copy(dAtA[i:], m.ServerIp)
   }
   if m.Port != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Port))
   }
   if m.Enable {
      dAtA[i] = 0x18
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   return i, nil
}

func (m *PushUrl) 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 *PushUrl) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Url) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Url)))
      i += copy(dAtA[i:], m.Url)
   }
   if m.Enable {
      dAtA[i] = 0x10
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   return i, nil
}

func (m *PushAttach) 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 *PushAttach) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.PushId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.PushId)))
      i += copy(dAtA[i:], m.PushId)
   }
   if m.Cam != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Cam.Size()))
      n4, err4 := m.Cam.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n4
   }
   if len(m.ServerId) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   if len(m.ServerName) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ServerName)))
      i += copy(dAtA[i:], m.ServerName)
   }
   if len(m.LocalIp) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.LocalIp)))
      i += copy(dAtA[i:], m.LocalIp)
   }
   if len(m.VideoUrl) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.VideoUrl)))
      i += copy(dAtA[i:], m.VideoUrl)
   }
   return i, nil
}

func (m *EsPersonCacheChange) 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 *EsPersonCacheChange) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Type != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
   }
   if len(m.TableId) > 0 {
      for _, s := range m.TableId {
         dAtA[i] = 0x12
         i++
         l = len(s)
         for l >= 1<<7 {
            dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
            l >>= 7
            i++
         }
         dAtA[i] = uint8(l)
         i++
         i += copy(dAtA[i:], s)
      }
   }
   if len(m.PersonId) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.PersonId)))
      i += copy(dAtA[i:], m.PersonId)
   }
   if len(m.Feature) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feature)))
      i += copy(dAtA[i:], m.Feature)
   }
   if m.Action != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Action))
   }
   if m.Enable != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Enable))
   }
   return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -3115,14 +5160,14 @@
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Areaid != 0 {
      n += 1 + sovProtomsg(uint64(m.Areaid))
   }
   if m.Longitude != 0 {
      n += 5
   }
   if m.Latitude != 0 {
      n += 5
   }
   if m.Floor != 0 {
      n += 1 + sovProtomsg(uint64(m.Floor))
   }
   l = len(m.Rtsp)
   if l > 0 {
@@ -3599,6 +5644,79 @@
   return n
}

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

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

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

func (m *SdkArg) Size() (n int) {
   if m == nil {
      return 0
@@ -3625,6 +5743,14 @@
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Range)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.DefaultValue)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.DefaultOperator)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
@@ -3693,6 +5819,357 @@
   }
   if m.DefenceState != 0 {
      n += 1 + sovProtomsg(uint64(m.DefenceState))
   }
   return n
}

func (m *VideotapeInfo) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.EsDataId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.TaskId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.ImgId != 0 {
      n += 1 + sovProtomsg(uint64(m.ImgId))
   }
   l = len(m.VideoUrl)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.SdkIds) > 0 {
      for _, s := range m.SdkIds {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if m.Type != 0 {
      n += 1 + sovProtomsg(uint64(m.Type))
   }
   return n
}

func (m *CompareArgs) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if len(m.TableIds) > 0 {
      for _, s := range m.TableIds {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if m.CompareThreshold != 0 {
      n += 5
   }
   l = len(m.FaceFeature)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.Tasks) > 0 {
      for _, s := range m.Tasks {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if len(m.TreeNodes) > 0 {
      for _, s := range m.TreeNodes {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if len(m.Tabs) > 0 {
      for _, s := range m.Tabs {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   l = len(m.AlarmLevel)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.SearchTime) > 0 {
      for _, s := range m.SearchTime {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   l = len(m.InputValue)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Collection)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Source {
      n += 2
   }
   l = len(m.AnalyServerId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *CompareEvent) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.EventType != 0 {
      n += 1 + sovProtomsg(uint64(m.EventType))
   }
   l = len(m.Payload)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *SdkCompareEach) 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.Tableid)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.CompareScore != 0 {
      n += 5
   }
   return n
}

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

func (m *EventPush) 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.TimeStart)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.TimeEnd)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.IsSatisfyAll {
      n += 2
   }
   l = len(m.RuleText)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Enable {
      n += 2
   }
   l = len(m.LinkType)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.LinkDevice)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.IpPorts) > 0 {
      for _, e := range m.IpPorts {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if len(m.Urls) > 0 {
      for _, e := range m.Urls {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if len(m.Rules) > 0 {
      for _, e := range m.Rules {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   return n
}

func (m *EventPushRule) 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.TopicType)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.TopicArg)
   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.RuleValue)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.EventPushId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *PushIpPort) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ServerIp)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Port != 0 {
      n += 1 + sovProtomsg(uint64(m.Port))
   }
   if m.Enable {
      n += 2
   }
   return n
}

func (m *PushUrl) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Url)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Enable {
      n += 2
   }
   return n
}

func (m *PushAttach) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.PushId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Cam != nil {
      l = m.Cam.Size()
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.ServerId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.ServerName)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.LocalIp)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.VideoUrl)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *EsPersonCacheChange) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Type != 0 {
      n += 1 + sovProtomsg(uint64(m.Type))
   }
   if len(m.TableId) > 0 {
      for _, s := range m.TableId {
         l = len(s)
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   l = len(m.PersonId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Feature)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Action != 0 {
      n += 1 + sovProtomsg(uint64(m.Action))
   }
   if m.Enable != 0 {
      n += 1 + sovProtomsg(uint64(m.Enable))
   }
   return n
}
@@ -4035,25 +6512,6 @@
         m.Addr = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Areaid", wireType)
         }
         m.Areaid = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Areaid |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 8:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
         }
@@ -4064,7 +6522,7 @@
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.Longitude = float32(math.Float32frombits(v))
      case 9:
      case 8:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
         }
@@ -4075,6 +6533,25 @@
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.Latitude = float32(math.Float32frombits(v))
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Floor", wireType)
         }
         m.Floor = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Floor |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 10:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Rtsp", wireType)
@@ -7379,6 +9856,496 @@
   }
   return nil
}
func (m *TaskSdkRule) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowProtomsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: TaskSdkRule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: TaskSdkRule: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TaskId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.Enable = bool(v != 0)
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SdkRules", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.SdkRules = append(m.SdkRules, &SdkRuleSet{})
         if err := m.SdkRules[len(m.SdkRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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

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

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *SdkArg) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
@@ -7589,6 +10556,70 @@
         m.Range = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field DefaultValue", 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.DefaultValue = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field DefaultOperator", 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.DefaultOperator = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
         }
@@ -8082,6 +11113,2364 @@
   }
   return nil
}
func (m *VideotapeInfo) 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: VideotapeInfo: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: VideotapeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field EsDataId", 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.EsDataId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TaskId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TaskId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ImgId", wireType)
         }
         m.ImgId = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ImgId |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VideoUrl", 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.VideoUrl = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SdkIds", 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.SdkIds = append(m.SdkIds, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
         }
         m.Type = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Type |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      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 *CompareArgs) 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: CompareArgs: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CompareArgs: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TableIds", 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.TableIds = append(m.TableIds, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 2:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field CompareThreshold", wireType)
         }
         var v uint32
         if (iNdEx + 4) > l {
            return io.ErrUnexpectedEOF
         }
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.CompareThreshold = float32(math.Float32frombits(v))
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceFeature", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.FaceFeature = append(m.FaceFeature[:0], dAtA[iNdEx:postIndex]...)
         if m.FaceFeature == nil {
            m.FaceFeature = []byte{}
         }
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Tasks", 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.Tasks = append(m.Tasks, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TreeNodes", 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.TreeNodes = append(m.TreeNodes, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Tabs", 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.Tabs = append(m.Tabs, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AlarmLevel", 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.AlarmLevel = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SearchTime", 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.SearchTime = append(m.SearchTime, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 9:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field InputValue", 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.InputValue = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 10:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Collection", 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.Collection = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 11:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Source", 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.Source = bool(v != 0)
      case 12:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AnalyServerId", 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.AnalyServerId = 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 *CompareEvent) 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: CompareEvent: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CompareEvent: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field EventType", wireType)
         }
         m.EventType = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.EventType |= CompareEventType(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
         if m.Payload == nil {
            m.Payload = []byte{}
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *SdkCompareEach) 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: SdkCompareEach: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkCompareEach: 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 Tableid", 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.Tableid = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 5 {
            return fmt.Errorf("proto: wrong wireType = %d for field CompareScore", wireType)
         }
         var v uint32
         if (iNdEx + 4) > l {
            return io.ErrUnexpectedEOF
         }
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.CompareScore = float32(math.Float32frombits(v))
      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 *SdkCompareResult) 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: SdkCompareResult: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkCompareResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CompareResult", 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.CompareResult = append(m.CompareResult, &SdkCompareEach{})
         if err := m.CompareResult[len(m.CompareResult)-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 *EventPush) 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: EventPush: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: EventPush: 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 TimeStart", 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.TimeStart = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TimeEnd", 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.TimeEnd = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IsSatisfyAll", 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.IsSatisfyAll = bool(v != 0)
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RuleText", 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.RuleText = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.Enable = bool(v != 0)
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field LinkType", 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.LinkType = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 9:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field LinkDevice", 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.LinkDevice = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 10:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field IpPorts", 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.IpPorts = append(m.IpPorts, &PushIpPort{})
         if err := m.IpPorts[len(m.IpPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 11:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Urls", 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.Urls = append(m.Urls, &PushUrl{})
         if err := m.Urls[len(m.Urls)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 12:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Rules = append(m.Rules, &EventPushRule{})
         if err := m.Rules[len(m.Rules)-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 *EventPushRule) 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: EventPushRule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: EventPushRule: 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 TopicType", 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.TopicType = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TopicArg", 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.TopicArg = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         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 5:
         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 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RuleValue", 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.RuleValue = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field EventPushId", 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.EventPushId = 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 *PushIpPort) 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: PushIpPort: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PushIpPort: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerIp", 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.ServerIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
         }
         m.Port = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Port |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.Enable = bool(v != 0)
      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 *PushUrl) 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: PushUrl: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PushUrl: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Url = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.Enable = bool(v != 0)
      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 *PushAttach) 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: PushAttach: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PushAttach: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PushId", 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.PushId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Cam", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Cam == nil {
            m.Cam = &Camera{}
         }
         if err := m.Cam.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerId", 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.ServerId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerName", 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.ServerName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field LocalIp", 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.LocalIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VideoUrl", 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.VideoUrl = 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 *EsPersonCacheChange) 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: EsPersonCacheChange: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: EsPersonCacheChange: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
         }
         m.Type = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Type |= EsCacheChanged(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TableId", 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.TableId = append(m.TableId, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PersonId", 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.PersonId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Feature", 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.Feature = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
         }
         m.Action = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Action |= DbAction(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
         }
         m.Enable = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Enable |= 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 skipProtomsg(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0