change golang/protobuf to gogo/protobuf

554325746@qq.com

2020-02-06 201ba0c95333cb07be9f955a936cd06a929e2e8f

 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 {
@@ -104,6 +110,34 @@
   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 (
@@ -126,7 +160,7 @@
}

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

//Area结构体
@@ -198,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"`
@@ -289,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
@@ -306,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
}
@@ -387,6 +421,59 @@
   return ""
}

//摄像机联动
type CameraLink struct {
   CameraIds  string `protobuf:"bytes,1,opt,name=camera_ids,json=cameraIds,proto3" json:"camera_ids,omitempty"`
   LinkTaskId string `protobuf:"bytes,2,opt,name=link_task_id,json=linkTaskId,proto3" json:"link_task_id,omitempty"`
}

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

var xxx_messageInfo_CameraLink proto.InternalMessageInfo

func (m *CameraLink) GetCameraIds() string {
   if m != nil {
      return m.CameraIds
   }
   return ""
}

func (m *CameraLink) GetLinkTaskId() string {
   if m != nil {
      return m.LinkTaskId
   }
   return ""
}

//摄像机的任务信息
type CameraAndTaskInfo struct {
   Camera *Camera `protobuf:"bytes,1,opt,name=camera,proto3" json:"camera,omitempty"`
@@ -397,7 +484,7 @@
func (m *CameraAndTaskInfo) String() string { return proto.CompactTextString(m) }
func (*CameraAndTaskInfo) ProtoMessage()    {}
func (*CameraAndTaskInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{2}
   return fileDescriptor_32de24555f916688, []int{3}
}
func (m *CameraAndTaskInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -456,7 +543,7 @@
func (m *Task) String() string { return proto.CompactTextString(m) }
func (*Task) ProtoMessage()    {}
func (*Task) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{3}
   return fileDescriptor_32de24555f916688, []int{4}
}
func (m *Task) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -550,7 +637,7 @@
func (m *TaskSdkInfo) String() string { return proto.CompactTextString(m) }
func (*TaskSdkInfo) ProtoMessage()    {}
func (*TaskSdkInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{4}
   return fileDescriptor_32de24555f916688, []int{5}
}
func (m *TaskSdkInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -602,7 +689,7 @@
func (m *SdkRun) String() string { return proto.CompactTextString(m) }
func (*SdkRun) ProtoMessage()    {}
func (*SdkRun) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{5}
   return fileDescriptor_32de24555f916688, []int{6}
}
func (m *SdkRun) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -654,7 +741,7 @@
func (m *TaskSdkRun) String() string { return proto.CompactTextString(m) }
func (*TaskSdkRun) ProtoMessage()    {}
func (*TaskSdkRun) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{6}
   return fileDescriptor_32de24555f916688, []int{7}
}
func (m *TaskSdkRun) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -699,25 +786,25 @@

//摄像机任务
type CameraTask struct {
   Id          string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraId    string    `protobuf:"bytes,2,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   TaskId      string    `protobuf:"bytes,3,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
   TimeRule    []*DayCtl `protobuf:"bytes,4,rep,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
   ReactRule   string    `protobuf:"bytes,5,opt,name=react_rule,json=reactRule,proto3" json:"react_rule,omitempty"`
   ReactDevice string    `protobuf:"bytes,6,opt,name=react_device,json=reactDevice,proto3" json:"react_device,omitempty"`
   DelFlag     bool      `protobuf:"varint,7,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
   UpdateFlag  bool      `protobuf:"varint,8,opt,name=update_flag,json=updateFlag,proto3" json:"update_flag,omitempty"`
   Enable      bool      `protobuf:"varint,9,opt,name=enable,proto3" json:"enable,omitempty"`
   Sort        int32     `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
   IsFull      bool      `protobuf:"varint,11,opt,name=is_full,json=isFull,proto3" json:"is_full,omitempty"`
   LinkTaskId  string    `protobuf:"bytes,12,opt,name=link_task_id,json=linkTaskId,proto3" json:"link_task_id,omitempty"`
   Id          string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraId    string `protobuf:"bytes,2,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   TaskId      string `protobuf:"bytes,3,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
   TimeRule    string `protobuf:"bytes,4,opt,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
   ReactRule   string `protobuf:"bytes,5,opt,name=react_rule,json=reactRule,proto3" json:"react_rule,omitempty"`
   ReactDevice string `protobuf:"bytes,6,opt,name=react_device,json=reactDevice,proto3" json:"react_device,omitempty"`
   DelFlag     bool   `protobuf:"varint,7,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
   UpdateFlag  bool   `protobuf:"varint,8,opt,name=update_flag,json=updateFlag,proto3" json:"update_flag,omitempty"`
   Enable      bool   `protobuf:"varint,9,opt,name=enable,proto3" json:"enable,omitempty"`
   Sort        int32  `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
   IsFull      bool   `protobuf:"varint,11,opt,name=is_full,json=isFull,proto3" json:"is_full,omitempty"`
   LinkTaskId  string `protobuf:"bytes,12,opt,name=link_task_id,json=linkTaskId,proto3" json:"link_task_id,omitempty"`
}

func (m *CameraTask) Reset()         { *m = CameraTask{} }
func (m *CameraTask) String() string { return proto.CompactTextString(m) }
func (*CameraTask) ProtoMessage()    {}
func (*CameraTask) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{7}
   return fileDescriptor_32de24555f916688, []int{8}
}
func (m *CameraTask) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -767,11 +854,11 @@
   return ""
}

func (m *CameraTask) GetTimeRule() []*DayCtl {
func (m *CameraTask) GetTimeRule() string {
   if m != nil {
      return m.TimeRule
   }
   return nil
   return ""
}

func (m *CameraTask) GetReactRule() string {
@@ -841,7 +928,7 @@
func (m *CameraTimerule) String() string { return proto.CompactTextString(m) }
func (*CameraTimerule) ProtoMessage()    {}
func (*CameraTimerule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{8}
   return fileDescriptor_32de24555f916688, []int{9}
}
func (m *CameraTimerule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -901,7 +988,7 @@
func (m *DayCtl) String() string { return proto.CompactTextString(m) }
func (*DayCtl) ProtoMessage()    {}
func (*DayCtl) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{9}
   return fileDescriptor_32de24555f916688, []int{10}
}
func (m *DayCtl) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -954,7 +1041,7 @@
func (m *TimeRange) String() string { return proto.CompactTextString(m) }
func (*TimeRange) ProtoMessage()    {}
func (*TimeRange) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{10}
   return fileDescriptor_32de24555f916688, []int{11}
}
func (m *TimeRange) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1008,7 +1095,7 @@
func (m *Polygon) String() string { return proto.CompactTextString(m) }
func (*Polygon) ProtoMessage()    {}
func (*Polygon) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{11}
   return fileDescriptor_32de24555f916688, []int{12}
}
func (m *Polygon) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1067,7 +1154,7 @@
func (m *CameraTaskArgs) String() string { return proto.CompactTextString(m) }
func (*CameraTaskArgs) ProtoMessage()    {}
func (*CameraTaskArgs) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{12}
   return fileDescriptor_32de24555f916688, []int{13}
}
func (m *CameraTaskArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1120,7 +1207,7 @@
func (m *TaskGroupArgs) String() string { return proto.CompactTextString(m) }
func (*TaskGroupArgs) ProtoMessage()    {}
func (*TaskGroupArgs) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{13}
   return fileDescriptor_32de24555f916688, []int{14}
}
func (m *TaskGroupArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1183,7 +1270,7 @@
func (m *GroupRule) String() string { return proto.CompactTextString(m) }
func (*GroupRule) ProtoMessage()    {}
func (*GroupRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{14}
   return fileDescriptor_32de24555f916688, []int{15}
}
func (m *GroupRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1273,7 +1360,7 @@
func (m *Rule) String() string { return proto.CompactTextString(m) }
func (*Rule) ProtoMessage()    {}
func (*Rule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{15}
   return fileDescriptor_32de24555f916688, []int{16}
}
func (m *Rule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1406,7 +1493,7 @@
func (m *Sdk) String() string { return proto.CompactTextString(m) }
func (*Sdk) ProtoMessage()    {}
func (*Sdk) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{16}
   return fileDescriptor_32de24555f916688, []int{17}
}
func (m *Sdk) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1529,7 +1616,7 @@
func (m *TaskSdkRule) String() string { return proto.CompactTextString(m) }
func (*TaskSdkRule) ProtoMessage()    {}
func (*TaskSdkRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{17}
   return fileDescriptor_32de24555f916688, []int{18}
}
func (m *TaskSdkRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1590,7 +1677,7 @@
func (m *SdkRuleSet) String() string { return proto.CompactTextString(m) }
func (*SdkRuleSet) ProtoMessage()    {}
func (*SdkRuleSet) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{18}
   return fileDescriptor_32de24555f916688, []int{19}
}
func (m *SdkRuleSet) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1658,7 +1745,7 @@
func (m *SdkRule) String() string { return proto.CompactTextString(m) }
func (*SdkRule) ProtoMessage()    {}
func (*SdkRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{19}
   return fileDescriptor_32de24555f916688, []int{20}
}
func (m *SdkRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1717,20 +1804,22 @@

//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{20}
   return fileDescriptor_32de24555f916688, []int{21}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1801,6 +1890,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
@@ -1820,7 +1923,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{21}
   return fileDescriptor_32de24555f916688, []int{22}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1892,7 +1995,7 @@
func (m *CameraPolygon) String() string { return proto.CompactTextString(m) }
func (*CameraPolygon) ProtoMessage()    {}
func (*CameraPolygon) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{22}
   return fileDescriptor_32de24555f916688, []int{23}
}
func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1982,15 +2085,16 @@
   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"`
   SdkIds   []string `protobuf:"bytes,5,rep,name=sdkIds,proto3" json:"sdkIds,omitempty"`
   Type     int32    `protobuf:"varint,6,opt,name=type,proto3" json:"type,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}
   return fileDescriptor_32de24555f916688, []int{24}
}
func (m *VideotapeInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2047,6 +2151,13 @@
   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
@@ -2068,7 +2179,7 @@
   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,rep,name=alarmLevel,proto3" json:"alarmLevel,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"`
@@ -2080,7 +2191,7 @@
func (m *CompareArgs) String() string { return proto.CompactTextString(m) }
func (*CompareArgs) ProtoMessage()    {}
func (*CompareArgs) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{24}
   return fileDescriptor_32de24555f916688, []int{25}
}
func (m *CompareArgs) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2151,11 +2262,11 @@
   return nil
}

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

func (m *CompareArgs) GetSearchTime() []string {
@@ -2193,6 +2304,58 @@
   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{26}
}
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"`
@@ -2203,7 +2366,7 @@
func (m *SdkCompareEach) String() string { return proto.CompactTextString(m) }
func (*SdkCompareEach) ProtoMessage()    {}
func (*SdkCompareEach) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{25}
   return fileDescriptor_32de24555f916688, []int{27}
}
func (m *SdkCompareEach) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2261,7 +2424,7 @@
func (m *SdkCompareResult) String() string { return proto.CompactTextString(m) }
func (*SdkCompareResult) ProtoMessage()    {}
func (*SdkCompareResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{26}
   return fileDescriptor_32de24555f916688, []int{28}
}
func (m *SdkCompareResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2316,7 +2479,7 @@
func (m *EventPush) String() string { return proto.CompactTextString(m) }
func (*EventPush) ProtoMessage()    {}
func (*EventPush) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{27}
   return fileDescriptor_32de24555f916688, []int{29}
}
func (m *EventPush) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2443,7 +2606,7 @@
func (m *EventPushRule) String() string { return proto.CompactTextString(m) }
func (*EventPushRule) ProtoMessage()    {}
func (*EventPushRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{28}
   return fileDescriptor_32de24555f916688, []int{30}
}
func (m *EventPushRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2531,7 +2694,7 @@
func (m *PushIpPort) String() string { return proto.CompactTextString(m) }
func (*PushIpPort) ProtoMessage()    {}
func (*PushIpPort) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{29}
   return fileDescriptor_32de24555f916688, []int{31}
}
func (m *PushIpPort) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2590,7 +2753,7 @@
func (m *PushUrl) String() string { return proto.CompactTextString(m) }
func (*PushUrl) ProtoMessage()    {}
func (*PushUrl) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{30}
   return fileDescriptor_32de24555f916688, []int{32}
}
func (m *PushUrl) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2633,19 +2796,104 @@
   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{33}
}
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,opt,name=table_id,json=tableId,proto3" json:"table_id,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  []byte         `protobuf:"bytes,4,opt,name=feature,proto3" json:"feature,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{31}
   return fileDescriptor_32de24555f916688, []int{34}
}
func (m *EsPersonCacheChange) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2681,11 +2929,11 @@
   return EsCacheChanged_T_DbTable
}

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

func (m *EsPersonCacheChange) GetPersonId() string {
@@ -2695,11 +2943,11 @@
   return ""
}

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

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

func (m *Area) Marshal() (dAtA []byte, err error) {
@@ -2985,22 +3258,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
@@ -3083,6 +3356,36 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RunServerId)))
      i += copy(dAtA[i:], m.RunServerId)
   }
   return i, nil
}

func (m *CameraLink) 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 *CameraLink) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.CameraIds) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraIds)))
      i += copy(dAtA[i:], m.CameraIds)
   }
   if len(m.LinkTaskId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.LinkTaskId)))
      i += copy(dAtA[i:], m.LinkTaskId)
   }
   return i, nil
}
@@ -3349,16 +3652,10 @@
      i += copy(dAtA[i:], m.TaskId)
   }
   if len(m.TimeRule) > 0 {
      for _, msg := range m.TimeRule {
         dAtA[i] = 0x22
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeRule)))
      i += copy(dAtA[i:], m.TimeRule)
   }
   if len(m.ReactRule) > 0 {
      dAtA[i] = 0x2a
@@ -4092,8 +4389,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))
   }
@@ -4243,9 +4552,15 @@
      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] = 0x2a
         dAtA[i] = 0x32
         i++
         l = len(s)
         for l >= 1<<7 {
@@ -4259,7 +4574,7 @@
      }
   }
   if m.Type != 0 {
      dAtA[i] = 0x30
      dAtA[i] = 0x38
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
   }
@@ -4354,19 +4669,10 @@
      }
   }
   if len(m.AlarmLevel) > 0 {
      for _, s := range m.AlarmLevel {
         dAtA[i] = 0x3a
         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)
      }
      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 {
@@ -4410,6 +4716,35 @@
      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
}
@@ -4729,6 +5064,64 @@
   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)
@@ -4750,10 +5143,19 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
   }
   if len(m.TableId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TableId)))
      i += copy(dAtA[i:], m.TableId)
      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
@@ -4771,6 +5173,11 @@
      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
}
@@ -4832,14 +5239,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 {
@@ -4880,6 +5287,23 @@
   l = len(m.RunServerId)
   if l > 0 {
      n += 2 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *CameraLink) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.CameraIds)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.LinkTaskId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}
@@ -5014,11 +5438,9 @@
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.TimeRule) > 0 {
      for _, e := range m.TimeRule {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   l = len(m.TimeRule)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.ReactRule)
   if l > 0 {
@@ -5418,6 +5840,14 @@
   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))
   }
   if m.Sort != 0 {
      n += 1 + sovProtomsg(uint64(m.Sort))
   }
@@ -5508,6 +5938,10 @@
   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)
@@ -5557,11 +5991,9 @@
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if len(m.AlarmLevel) > 0 {
      for _, s := range m.AlarmLevel {
         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 {
@@ -5581,6 +6013,22 @@
      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))
   }
@@ -5755,6 +6203,39 @@
   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
@@ -5764,9 +6245,11 @@
   if m.Type != 0 {
      n += 1 + sovProtomsg(uint64(m.Type))
   }
   l = len(m.TableId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   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 {
@@ -5778,6 +6261,9 @@
   }
   if m.Action != 0 {
      n += 1 + sovProtomsg(uint64(m.Action))
   }
   if m.Enable != 0 {
      n += 1 + sovProtomsg(uint64(m.Enable))
   }
   return n
}
@@ -6120,25 +6606,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)
         }
@@ -6149,7 +6616,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)
         }
@@ -6160,6 +6627,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)
@@ -6461,6 +6947,123 @@
            return io.ErrUnexpectedEOF
         }
         m.RunServerId = 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 *CameraLink) 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: CameraLink: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraLink: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraIds", 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.CameraIds = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field LinkTaskId", 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.LinkTaskId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
@@ -7374,7 +7977,7 @@
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TimeRule", wireType)
         }
         var msglen int
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
@@ -7384,25 +7987,23 @@
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TimeRule = append(m.TimeRule, &DayCtl{})
         if err := m.TimeRule[len(m.TimeRule)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         m.TimeRule = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
@@ -10164,6 +10765,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)
         }
@@ -10803,6 +11468,38 @@
         }
      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
@@ -10833,7 +11530,7 @@
         }
         m.SdkIds = append(m.SdkIds, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 6:
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
         }
@@ -11108,7 +11805,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AlarmLevel = append(m.AlarmLevel, string(dAtA[iNdEx:postIndex]))
         m.AlarmLevel = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
@@ -11257,6 +11954,112 @@
            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
@@ -12422,6 +13225,255 @@
   }
   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
@@ -12500,7 +13552,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TableId = string(dAtA[iNdEx:postIndex])
         m.TableId = append(m.TableId, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
@@ -12538,7 +13590,7 @@
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Feature", wireType)
         }
         var byteLen int
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
@@ -12548,25 +13600,23 @@
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + byteLen
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Feature = append(m.Feature[:0], dAtA[iNdEx:postIndex]...)
         if m.Feature == nil {
            m.Feature = []byte{}
         }
         m.Feature = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 0 {
@@ -12587,6 +13637,25 @@
               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:])