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 {
@@ -226,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"`
@@ -317,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
@@ -334,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
}
@@ -415,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"`
@@ -425,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)
@@ -484,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)
@@ -578,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)
@@ -630,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)
@@ -682,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)
@@ -727,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)
@@ -795,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 {
@@ -869,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)
@@ -929,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)
@@ -982,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)
@@ -1036,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)
@@ -1095,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)
@@ -1148,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)
@@ -1211,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)
@@ -1301,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)
@@ -1434,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)
@@ -1557,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)
@@ -1618,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)
@@ -1686,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)
@@ -1760,7 +1819,7 @@
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)
@@ -1864,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)
@@ -1936,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)
@@ -2026,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)
@@ -2091,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
@@ -2112,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       []int32  `protobuf:"varint,7,rep,packed,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"`
@@ -2124,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)
@@ -2195,11 +2262,11 @@
   return nil
}

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

func (m *CompareArgs) GetSearchTime() []string {
@@ -2246,7 +2313,7 @@
func (m *CompareEvent) String() string { return proto.CompactTextString(m) }
func (*CompareEvent) ProtoMessage()    {}
func (*CompareEvent) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{25}
   return fileDescriptor_32de24555f916688, []int{26}
}
func (m *CompareEvent) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2299,7 +2366,7 @@
func (m *SdkCompareEach) String() string { return proto.CompactTextString(m) }
func (*SdkCompareEach) ProtoMessage()    {}
func (*SdkCompareEach) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{26}
   return fileDescriptor_32de24555f916688, []int{27}
}
func (m *SdkCompareEach) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2357,7 +2424,7 @@
func (m *SdkCompareResult) String() string { return proto.CompactTextString(m) }
func (*SdkCompareResult) ProtoMessage()    {}
func (*SdkCompareResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{27}
   return fileDescriptor_32de24555f916688, []int{28}
}
func (m *SdkCompareResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2412,7 +2479,7 @@
func (m *EventPush) String() string { return proto.CompactTextString(m) }
func (*EventPush) ProtoMessage()    {}
func (*EventPush) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{28}
   return fileDescriptor_32de24555f916688, []int{29}
}
func (m *EventPush) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2539,7 +2606,7 @@
func (m *EventPushRule) String() string { return proto.CompactTextString(m) }
func (*EventPushRule) ProtoMessage()    {}
func (*EventPushRule) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{29}
   return fileDescriptor_32de24555f916688, []int{30}
}
func (m *EventPushRule) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2627,7 +2694,7 @@
func (m *PushIpPort) String() string { return proto.CompactTextString(m) }
func (*PushIpPort) ProtoMessage()    {}
func (*PushIpPort) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{30}
   return fileDescriptor_32de24555f916688, []int{31}
}
func (m *PushIpPort) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2686,7 +2753,7 @@
func (m *PushUrl) String() string { return proto.CompactTextString(m) }
func (*PushUrl) ProtoMessage()    {}
func (*PushUrl) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{31}
   return fileDescriptor_32de24555f916688, []int{32}
}
func (m *PushUrl) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2729,6 +2796,90 @@
   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,rep,name=table_id,json=tableId,proto3" json:"table_id,omitempty"`
@@ -2742,7 +2893,7 @@
func (m *EsPersonCacheChange) String() string { return proto.CompactTextString(m) }
func (*EsPersonCacheChange) ProtoMessage()    {}
func (*EsPersonCacheChange) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{32}
   return fileDescriptor_32de24555f916688, []int{34}
}
func (m *EsPersonCacheChange) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2820,6 +2971,7 @@
   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")
@@ -2850,168 +3002,176 @@
   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{
   // 2472 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x4b, 0x8f, 0x24, 0x47,
   0x11, 0x9e, 0xea, 0x77, 0x45, 0x77, 0xcf, 0xd6, 0xe6, 0x2e, 0x76, 0x79, 0x8d, 0xc7, 0xe3, 0x62,
   0x2d, 0x2f, 0x2b, 0xdb, 0xa0, 0xb5, 0x0f, 0x88, 0x03, 0xd2, 0x78, 0x1f, 0xa8, 0x25, 0x63, 0x86,
   0x9a, 0xd9, 0xe5, 0x46, 0x29, 0xbb, 0x2b, 0xa7, 0xa7, 0x34, 0x39, 0x55, 0xa5, 0xcc, 0xaa, 0xb5,
   0xe7, 0xc0, 0x0f, 0xe0, 0x04, 0x7f, 0x81, 0x7f, 0x82, 0x38, 0x71, 0xe0, 0xe0, 0x23, 0x9c, 0x8c,
   0x6c, 0x09, 0x21, 0x21, 0x7e, 0x02, 0x08, 0x45, 0x64, 0x66, 0x3d, 0x7a, 0x76, 0xed, 0x3d, 0x75,
   0xc6, 0x17, 0x51, 0xf9, 0x88, 0x77, 0x34, 0xec, 0x97, 0xaa, 0xa8, 0x8a, 0x4b, 0xbd, 0xfd, 0x90,
   0x16, 0x6c, 0xe6, 0xe8, 0x3b, 0xb0, 0xe6, 0x5a, 0x18, 0x34, 0x7a, 0x02, 0xa3, 0x23, 0x25, 0x38,
   0xdb, 0x87, 0x41, 0x96, 0x86, 0xde, 0xa1, 0x77, 0x6f, 0x1c, 0x0f, 0xb2, 0x94, 0xdd, 0x81, 0x59,
   0xc9, 0x95, 0xc8, 0xab, 0x2c, 0x0d, 0x07, 0x84, 0x36, 0x34, 0x63, 0x30, 0xca, 0xf9, 0xa5, 0x08,
   0x87, 0x87, 0xde, 0x3d, 0x3f, 0xa6, 0x75, 0xf4, 0xbf, 0x21, 0x4c, 0x1e, 0xf2, 0x4b, 0xa1, 0xba,
   0x5b, 0xf9, 0xb4, 0x95, 0x13, 0x1f, 0xb4, 0xe2, 0xec, 0x36, 0x8c, 0xb9, 0xcc, 0xb8, 0xb6, 0x7b,
   0x18, 0x82, 0xbd, 0x03, 0x0b, 0x9d, 0xf3, 0x52, 0x9f, 0x17, 0x55, 0x52, 0x2b, 0x19, 0x8e, 0x88,
   0x39, 0x77, 0xd8, 0x53, 0x25, 0x71, 0xb3, 0xea, 0xaa, 0x14, 0xe1, 0x98, 0xee, 0x44, 0x6b, 0xc4,
   0x78, 0x9a, 0xaa, 0x70, 0x62, 0x0e, 0xc0, 0x35, 0x7b, 0x0d, 0x26, 0x5c, 0x09, 0x9e, 0xa5, 0xe1,
   0x94, 0x24, 0x2d, 0xc5, 0xbe, 0x0f, 0xbe, 0x2c, 0xf2, 0x6d, 0x56, 0xd5, 0xa9, 0x08, 0x67, 0x87,
   0xde, 0xbd, 0x41, 0xdc, 0x02, 0xf8, 0x6a, 0xc9, 0x2b, 0xc3, 0xf4, 0x89, 0xd9, 0xd0, 0x78, 0x8a,
   0xaa, 0x74, 0x19, 0x82, 0x39, 0x05, 0xd7, 0xf4, 0xd4, 0x32, 0x9c, 0xdb, 0xa7, 0x96, 0x28, 0x53,
   0x16, 0xaa, 0x0a, 0x17, 0xe6, 0x76, 0xb8, 0xc6, 0x3d, 0x6b, 0x2d, 0x14, 0xa9, 0x60, 0x49, 0x92,
   0x0d, 0x6d, 0xb4, 0xac, 0xf5, 0xe7, 0x85, 0x4a, 0xc3, 0x7d, 0xc3, 0x73, 0x34, 0xaa, 0x68, 0xad,
   0x78, 0x9e, 0x86, 0x37, 0x8c, 0x8a, 0x88, 0xc0, 0x2f, 0x94, 0xd0, 0x42, 0x3d, 0x17, 0x69, 0x18,
   0x98, 0x2f, 0x1c, 0xcd, 0xde, 0x02, 0xc8, 0x74, 0xa2, 0xea, 0x3c, 0xcf, 0xf2, 0x6d, 0x78, 0xf3,
   0xd0, 0xbb, 0x37, 0x8b, 0xfd, 0x4c, 0xc7, 0x06, 0x40, 0xb6, 0xaa, 0xf3, 0x44, 0xe4, 0x7c, 0x2d,
   0x45, 0xc8, 0x0c, 0x5b, 0xd5, 0xf9, 0x63, 0x02, 0xd8, 0x1b, 0x30, 0x43, 0x36, 0x69, 0xf7, 0x16,
   0xdd, 0x7f, 0xaa, 0xea, 0xfc, 0x14, 0x15, 0x1c, 0xc1, 0x12, 0x59, 0x74, 0x8c, 0x4a, 0xb2, 0x34,
   0xbc, 0x6d, 0x0c, 0xa3, 0xea, 0xfc, 0x84, 0xb0, 0x55, 0x1a, 0x6d, 0xe0, 0xa6, 0xb1, 0xff, 0x51,
   0x9e, 0x9e, 0x72, 0x7d, 0xb1, 0xca, 0xcf, 0x0a, 0x76, 0x0f, 0x26, 0x1b, 0x02, 0xc9, 0x1d, 0xe6,
   0x0f, 0x82, 0x0f, 0x1b, 0xa7, 0x34, 0xc2, 0xb1, 0xe5, 0xb3, 0xbb, 0x30, 0xae, 0xb8, 0xbe, 0xd0,
   0xe1, 0xe0, 0x70, 0x78, 0x6f, 0xfe, 0x60, 0xbf, 0x15, 0xc4, 0xcd, 0x62, 0xc3, 0x8c, 0xbe, 0xf2,
   0x60, 0x84, 0x34, 0x9a, 0x17, 0x91, 0xc6, 0xcf, 0x2c, 0x85, 0xea, 0xc1, 0x55, 0xc7, 0xdf, 0x1a,
   0x9a, 0xbd, 0x09, 0xfe, 0x46, 0x09, 0x5e, 0x89, 0x84, 0x57, 0xd6, 0xef, 0x66, 0x06, 0x38, 0xaa,
   0x3a, 0xcc, 0xf5, 0x95, 0xf5, 0x3b, 0xcb, 0xfc, 0xe4, 0x0a, 0x99, 0x75, 0x99, 0xda, 0x2f, 0xc7,
   0xd6, 0x86, 0x04, 0x1c, 0x55, 0x78, 0x15, 0xab, 0xd2, 0x09, 0xa9, 0xd4, 0x52, 0xa8, 0xcf, 0x4c,
   0x27, 0x5c, 0x72, 0x75, 0x49, 0x3e, 0x38, 0x8b, 0xa7, 0x99, 0x3e, 0x42, 0x12, 0x59, 0xa9, 0x90,
   0xc9, 0x99, 0xe4, 0x5b, 0xf2, 0xc1, 0x59, 0x3c, 0x4d, 0x85, 0x7c, 0x22, 0xf9, 0x36, 0x3a, 0x85,
   0x39, 0x3e, 0xf0, 0x24, 0x35, 0x0a, 0x8c, 0x60, 0x84, 0xf7, 0xb7, 0xea, 0xdb, 0xd5, 0x0a, 0xf1,
   0xd8, 0x3b, 0x30, 0xd2, 0x69, 0xa3, 0xb9, 0x65, 0x2b, 0x73, 0x92, 0x5e, 0xc4, 0xc4, 0x8a, 0x7e,
   0x0a, 0x13, 0x24, 0xea, 0x9c, 0x7d, 0x0f, 0x26, 0x59, 0xb9, 0x49, 0x1a, 0xc5, 0x8d, 0xb3, 0x72,
   0xb3, 0x4a, 0xf1, 0x46, 0x3a, 0xbd, 0x30, 0xc6, 0x37, 0x7a, 0x9b, 0xea, 0xf4, 0x02, 0x8d, 0x1f,
   0x3d, 0x03, 0xb0, 0x37, 0xc2, 0xef, 0x5f, 0xe5, 0x42, 0x77, 0x7b, 0x17, 0x0a, 0xfa, 0x17, 0xaa,
   0x73, 0x7b, 0xa7, 0x7f, 0x0e, 0x00, 0x8c, 0x13, 0x90, 0x45, 0x77, 0xb3, 0x06, 0x1a, 0x84, 0xb8,
   0x89, 0xcd, 0x40, 0x68, 0x10, 0x02, 0x56, 0x29, 0x7b, 0x1d, 0xa6, 0x78, 0x12, 0xb2, 0x86, 0xad,
   0xfd, 0x57, 0x29, 0xfb, 0x00, 0xfc, 0x2a, 0xbb, 0x14, 0x89, 0xaa, 0xa5, 0x08, 0x47, 0xbb, 0xe7,
   0x3f, 0xe2, 0x57, 0x0f, 0x2b, 0x19, 0xcf, 0x50, 0x24, 0xae, 0xa5, 0xa0, 0x90, 0x10, 0x7c, 0x53,
   0x19, 0x79, 0x63, 0x59, 0x9f, 0x10, 0x62, 0xbf, 0x03, 0x0b, 0xc3, 0x4e, 0xc5, 0xf3, 0x6c, 0x23,
   0x6c, 0x82, 0x99, 0x13, 0xf6, 0x88, 0xa0, 0x9e, 0x29, 0xa7, 0x3d, 0x53, 0xb2, 0xb7, 0x61, 0x6e,
   0xbd, 0xa6, 0x63, 0x68, 0x30, 0x10, 0x09, 0xb4, 0x9e, 0xe3, 0xf7, 0x3c, 0x87, 0xc1, 0x48, 0x63,
   0x16, 0x01, 0x93, 0x45, 0x70, 0x8d, 0x2f, 0xce, 0x74, 0x72, 0x56, 0x4b, 0x49, 0xe9, 0x66, 0x16,
   0x4f, 0x32, 0xfd, 0xa4, 0x96, 0x92, 0x1d, 0xc2, 0x42, 0x66, 0xf9, 0x45, 0xe2, 0xf4, 0xb1, 0xa0,
   0x3b, 0x02, 0x62, 0x14, 0x86, 0x69, 0xf4, 0x2b, 0xd8, 0xb7, 0x7a, 0xce, 0x2e, 0x05, 0x3e, 0xf4,
   0x95, 0x32, 0xf4, 0x9b, 0x5d, 0x4d, 0xda, 0x68, 0x71, 0x7a, 0x8b, 0x3e, 0x83, 0x89, 0xd1, 0x25,
   0x0b, 0x60, 0x98, 0xf2, 0x2b, 0x5b, 0x38, 0x70, 0xc9, 0x1e, 0x00, 0x98, 0x0f, 0x79, 0xbe, 0x15,
   0xd6, 0x07, 0x6e, 0x75, 0xfc, 0x04, 0xf7, 0x40, 0x56, 0x4c, 0xfb, 0xd3, 0x32, 0xfa, 0x08, 0xfc,
   0x06, 0xc7, 0xc4, 0xa7, 0x2b, 0xae, 0x2a, 0xe7, 0xa1, 0x44, 0xe0, 0x41, 0x22, 0x77, 0x9e, 0x80,
   0xcb, 0xe8, 0x19, 0x4c, 0x8f, 0x0b, 0x79, 0xb5, 0x2d, 0xf2, 0x57, 0x7a, 0xd0, 0x7b, 0x30, 0x29,
   0x8b, 0x2c, 0xaf, 0xb0, 0xe6, 0xe0, 0x9d, 0x6e, 0xb4, 0x77, 0x3a, 0x46, 0x3c, 0xb6, 0xec, 0x68,
   0xd3, 0xe8, 0x8b, 0xeb, 0x8b, 0x23, 0xb5, 0xd5, 0x7d, 0x5f, 0xf4, 0x76, 0x7c, 0xf1, 0x63, 0xf0,
   0x49, 0xf7, 0x5c, 0x6d, 0x9d, 0xcb, 0xbf, 0xde, 0x0f, 0x8b, 0x9f, 0xab, 0xa2, 0x2e, 0x71, 0x23,
   0x93, 0x8c, 0x70, 0x15, 0x3d, 0x87, 0x65, 0x8f, 0xd5, 0x75, 0x69, 0xaf, 0xe7, 0xd2, 0x1f, 0xc3,
   0x7c, 0x8b, 0x52, 0x64, 0x09, 0x7d, 0x5d, 0xa1, 0xb4, 0x05, 0x5a, 0x25, 0x86, 0xad, 0x5b, 0xea,
   0x8e, 0x6f, 0x0d, 0xbb, 0xbe, 0x15, 0xfd, 0xd5, 0x03, 0xbf, 0xf9, 0x02, 0xbd, 0xd7, 0xec, 0xdd,
   0x9c, 0x3a, 0x25, 0x7a, 0x45, 0xc5, 0xc4, 0xb0, 0x2a, 0xf1, 0x45, 0x65, 0x15, 0xe9, 0x13, 0x72,
   0x2a, 0xbe, 0xa8, 0xd0, 0xb9, 0x29, 0xb5, 0x25, 0x52, 0x3c, 0x17, 0x92, 0x0e, 0x19, 0xc7, 0x40,
   0xd0, 0xa7, 0x88, 0x60, 0x42, 0x37, 0x17, 0x1e, 0xed, 0x26, 0x74, 0xba, 0xab, 0x61, 0x52, 0xde,
   0x11, 0x55, 0xd2, 0x94, 0x74, 0xcc, 0x3b, 0xa2, 0xa2, 0xa2, 0xf3, 0x03, 0x58, 0xa6, 0xe2, 0x4c,
   0xe4, 0x1b, 0x91, 0xe8, 0x8a, 0x57, 0x2e, 0xbd, 0x2e, 0x2c, 0x78, 0x82, 0x58, 0xf4, 0xef, 0x01,
   0x8c, 0xe2, 0x17, 0xb9, 0xf4, 0x5d, 0xd8, 0xb7, 0x26, 0x73, 0x5a, 0x35, 0x4f, 0x58, 0x6c, 0x1a,
   0xd3, 0xae, 0x76, 0x92, 0xcc, 0x70, 0xc7, 0xb0, 0x6f, 0x01, 0x94, 0xc6, 0xbf, 0x90, 0x6b, 0x6a,
   0x82, 0x6f, 0x91, 0x55, 0x8a, 0x99, 0x14, 0x53, 0x66, 0x96, 0xda, 0x8b, 0x8f, 0x75, 0x8a, 0x5b,
   0x46, 0xb0, 0x44, 0x98, 0xab, 0x6d, 0x62, 0x3a, 0x1c, 0x9b, 0x34, 0x74, 0x8a, 0x86, 0x3f, 0xa2,
   0x3e, 0xe7, 0x0e, 0xcc, 0x8a, 0x52, 0x28, 0x5e, 0x15, 0x8a, 0x92, 0x86, 0x1f, 0x37, 0x34, 0x3e,
   0xdb, 0xad, 0x8d, 0x5a, 0x66, 0xe6, 0xde, 0x0e, 0x74, 0x05, 0xd9, 0x1d, 0xf2, 0x9c, 0xcb, 0xda,
   0x24, 0x90, 0xe6, 0x90, 0x67, 0x08, 0xbd, 0x30, 0x8b, 0x50, 0x21, 0x97, 0x22, 0xf9, 0x3c, 0xab,
   0xce, 0x93, 0x52, 0x09, 0xdb, 0xba, 0xcc, 0x11, 0xfc, 0x75, 0x56, 0x9d, 0x1f, 0xab, 0xbe, 0x4f,
   0x2c, 0x7a, 0x3e, 0x11, 0xfd, 0x69, 0x00, 0xc3, 0x93, 0xf4, 0x7a, 0xae, 0x6e, 0x8b, 0xca, 0xe0,
   0x65, 0x45, 0x65, 0xd8, 0x2b, 0x2a, 0x8e, 0x45, 0x41, 0x3a, 0x6a, 0x58, 0x9f, 0x61, 0x9c, 0xde,
   0x85, 0x11, 0x85, 0xd2, 0xf8, 0x05, 0xd5, 0xe3, 0x48, 0x6d, 0x63, 0xe2, 0xe2, 0xeb, 0xb2, 0x4d,
   0x91, 0xbb, 0x9e, 0x0f, 0xd7, 0x98, 0x22, 0xb0, 0x6b, 0x34, 0x1a, 0xc5, 0x25, 0x7a, 0xa9, 0xad,
   0xea, 0x98, 0x6b, 0xac, 0x2a, 0xc1, 0x40, 0x98, 0x70, 0x3a, 0x39, 0x9a, 0x04, 0x8c, 0x1a, 0x6d,
   0x8e, 0x26, 0x81, 0x5e, 0x5f, 0x00, 0x3b, 0x7d, 0x41, 0x1b, 0x64, 0xf3, 0xdd, 0xd2, 0xdf, 0x14,
   0x05, 0xd3, 0x0a, 0x36, 0xf5, 0xbd, 0x68, 0xea, 0x3b, 0xb9, 0xad, 0xed, 0x63, 0x56, 0xbb, 0x41,
   0xdf, 0xee, 0x3c, 0xe8, 0xed, 0xfc, 0x63, 0xd2, 0x1b, 0x85, 0xb8, 0x4d, 0x63, 0xb7, 0x77, 0xca,
   0xab, 0x14, 0x27, 0xa2, 0x8a, 0x1b, 0xa9, 0xa8, 0x06, 0x68, 0x71, 0xca, 0xad, 0x69, 0x7b, 0x9c,
   0xf5, 0xd9, 0xdb, 0x60, 0x2c, 0xd6, 0x37, 0xdf, 0x7b, 0x2e, 0x82, 0xcd, 0x41, 0x37, 0xaf, 0x1d,
   0xe4, 0x82, 0xd8, 0x79, 0xda, 0xa8, 0xf5, 0xb4, 0xe8, 0xb7, 0x30, 0x75, 0x6f, 0xdc, 0xf5, 0x96,
   0x6b, 0x11, 0x32, 0xf8, 0xf6, 0x08, 0x19, 0xee, 0x44, 0xc8, 0x35, 0xe7, 0x1f, 0x5d, 0x73, 0xfe,
   0xe8, 0x5f, 0x1e, 0x75, 0x3c, 0x47, 0x6a, 0xdb, 0x8e, 0x1a, 0x5e, 0x77, 0xd4, 0x78, 0x51, 0x85,
   0x70, 0xb3, 0x85, 0x9d, 0x6b, 0xdc, 0x6c, 0x71, 0x59, 0x6b, 0xf3, 0xb6, 0x59, 0x4c, 0x6b, 0xc4,
   0xea, 0x3c, 0x73, 0x9d, 0x20, 0xad, 0xf1, 0x14, 0x53, 0xf0, 0x8c, 0x43, 0x1a, 0xc2, 0xe6, 0x30,
   0x5e, 0xcb, 0xca, 0x5e, 0xd5, 0xf8, 0xe6, 0xc2, 0x82, 0x26, 0x50, 0x7f, 0x08, 0x81, 0x13, 0x6a,
   0xde, 0x6c, 0x3c, 0xf5, 0x86, 0xc5, 0x7f, 0xe9, 0x9e, 0xee, 0x34, 0xed, 0x77, 0x34, 0xfd, 0x7b,
   0x0f, 0x6e, 0x3c, 0x5a, 0x3f, 0x3c, 0xc7, 0x03, 0x7f, 0x21, 0xb4, 0xe6, 0x5b, 0xc1, 0xde, 0xc7,
   0x6e, 0x1a, 0xbd, 0x07, 0xdf, 0xbc, 0xff, 0xe0, 0xb5, 0x6e, 0x3d, 0x5a, 0x4b, 0x61, 0x84, 0xd3,
   0xd8, 0x08, 0x59, 0x03, 0x0d, 0x1a, 0x03, 0xdd, 0x87, 0x09, 0xdf, 0x54, 0x59, 0x91, 0x93, 0x26,
   0xf6, 0x1f, 0xb0, 0x4e, 0x07, 0xb5, 0x3e, 0x22, 0x4e, 0x6c, 0x25, 0x28, 0x0e, 0xf3, 0xb3, 0xc2,
   0xda, 0x80, 0xd6, 0xd1, 0x7f, 0x3c, 0x58, 0x9a, 0x0a, 0xfa, 0xb2, 0xfa, 0xfc, 0xad, 0xcd, 0xdd,
   0x0b, 0xc6, 0x4b, 0x16, 0xc2, 0xd4, 0x66, 0x5e, 0x97, 0x2e, 0x2c, 0x89, 0x3d, 0x5a, 0xa5, 0xb2,
   0xed, 0x56, 0xa8, 0x44, 0x66, 0xb9, 0xab, 0x22, 0x73, 0x8b, 0x7d, 0x9a, 0xe5, 0x82, 0xbd, 0x0b,
   0xfb, 0x69, 0xa6, 0x04, 0x5d, 0xd8, 0x08, 0x19, 0x23, 0x2d, 0x1b, 0x94, 0xc4, 0x9c, 0xf9, 0xa7,
   0x1d, 0xf3, 0x5f, 0x2b, 0x42, 0x33, 0xd2, 0x7c, 0xbf, 0x08, 0xfd, 0xd1, 0x83, 0xe5, 0xb3, 0x2c,
   0x15, 0x45, 0xc5, 0x4b, 0x41, 0x6d, 0xfb, 0x1d, 0x98, 0x09, 0xfd, 0x88, 0x57, 0xbc, 0x89, 0xb4,
   0x86, 0x46, 0x9e, 0x7b, 0xea, 0xb5, 0xa7, 0xb7, 0xe9, 0xa0, 0xdf, 0xd6, 0x62, 0x80, 0x5e, 0x6e,
   0x57, 0xa6, 0x0a, 0x0d, 0x63, 0x43, 0xa0, 0x34, 0xc5, 0xaf, 0xc9, 0x95, 0x7e, 0x6c, 0xa9, 0xe6,
   0x21, 0x93, 0x76, 0x46, 0x8e, 0xfe, 0x3b, 0x80, 0xf9, 0xc3, 0xe2, 0x12, 0x67, 0x78, 0x6a, 0x37,
   0x68, 0x50, 0x5a, 0x4b, 0x81, 0x5f, 0x7b, 0xf4, 0x75, 0x43, 0xb3, 0xfb, 0x10, 0x6c, 0x8c, 0xe8,
   0xe9, 0xb9, 0x12, 0xfa, 0xbc, 0x90, 0xe6, 0xa6, 0x83, 0xf8, 0x1a, 0xce, 0x0e, 0x61, 0x7e, 0xc6,
   0x37, 0xe2, 0x89, 0xe0, 0x55, 0xad, 0x8c, 0xcd, 0x16, 0x71, 0x17, 0xc2, 0xbb, 0x9b, 0xc9, 0x6e,
   0x44, 0xc7, 0x18, 0x02, 0xe7, 0xf0, 0x4a, 0x09, 0xf1, 0x59, 0x91, 0x0a, 0x77, 0xfd, 0x16, 0xa0,
   0x17, 0xf0, 0x35, 0xd6, 0xce, 0x21, 0x99, 0x82, 0xaf, 0x35, 0x3b, 0x80, 0x4e, 0x7b, 0x11, 0x4e,
   0x0f, 0x87, 0x3b, 0x0d, 0xc7, 0x01, 0x80, 0x16, 0x5c, 0x6d, 0xce, 0x4f, 0x4d, 0xaa, 0xc7, 0x2f,
   0x3b, 0x08, 0xf2, 0xb3, 0xbc, 0xac, 0x4d, 0xd0, 0xb9, 0x4c, 0xdf, 0x22, 0xc8, 0xdf, 0x14, 0x52,
   0x1a, 0x87, 0xb0, 0xa9, 0xbe, 0x83, 0x90, 0xb6, 0x8b, 0x5a, 0x6d, 0x9a, 0x64, 0x6f, 0x28, 0x76,
   0x17, 0x96, 0x3c, 0xe7, 0xf2, 0xca, 0x4d, 0xc2, 0xb6, 0x68, 0xf6, 0xc1, 0x68, 0x0d, 0x0b, 0xab,
   0xfe, 0xc7, 0xcf, 0x45, 0x5e, 0xb1, 0x9f, 0x80, 0x2f, 0x70, 0x81, 0xd5, 0xd0, 0x46, 0xe9, 0x9d,
   0xce, 0x70, 0xdc, 0x11, 0x45, 0x89, 0xb8, 0x15, 0xa6, 0x50, 0xe0, 0x57, 0xb2, 0xe0, 0xc6, 0x28,
   0x8b, 0xd8, 0x91, 0xd1, 0x6f, 0x60, 0xff, 0x24, 0xbd, 0x70, 0xdf, 0xf2, 0xcd, 0xf9, 0xb5, 0xb8,
   0x0b, 0xb1, 0xc9, 0x5c, 0x4b, 0xd1, 0x44, 0x9d, 0x23, 0x59, 0x04, 0x0b, 0x6b, 0xdb, 0x93, 0x4d,
   0x61, 0x0d, 0x39, 0x88, 0x7b, 0x58, 0x14, 0x43, 0xd0, 0xee, 0x1f, 0x0b, 0x5d, 0xcb, 0x8a, 0xfd,
   0x0c, 0x96, 0x9b, 0x2e, 0x40, 0xce, 0x34, 0x7f, 0x10, 0xf6, 0x8a, 0x45, 0xe7, 0x4a, 0x71, 0x5f,
   0x3c, 0xfa, 0xdd, 0x10, 0x7c, 0x7a, 0xe6, 0x71, 0xad, 0xcf, 0x5f, 0xa9, 0x8f, 0x7f, 0xcb, 0xce,
   0x17, 0x66, 0x46, 0x30, 0x71, 0x42, 0xa3, 0xc4, 0x09, 0xcd, 0x09, 0x6f, 0x00, 0x8d, 0x29, 0x09,
   0x0e, 0x0b, 0x36, 0x55, 0x20, 0xfd, 0x38, 0xa7, 0x9e, 0x30, 0xd3, 0x89, 0xe6, 0x55, 0xa6, 0xcf,
   0xae, 0x12, 0x2e, 0x25, 0x25, 0x8b, 0x59, 0xbc, 0xc8, 0xf4, 0x89, 0x01, 0x8f, 0xa4, 0xc4, 0xdc,
   0x44, 0x3d, 0x12, 0xf5, 0xbd, 0x13, 0xfb, 0x17, 0x4b, 0x2d, 0x05, 0xb5, 0xbd, 0x6d, 0x5d, 0x9e,
   0xf6, 0xea, 0xf2, 0x9b, 0xe0, 0x9b, 0x29, 0xac, 0xed, 0xd8, 0x66, 0x34, 0x82, 0xa1, 0xc5, 0xde,
   0x86, 0x39, 0x31, 0xed, 0x14, 0xe9, 0xb7, 0x13, 0x9a, 0x1d, 0x22, 0x7f, 0x04, 0xb3, 0xac, 0x4c,
   0xca, 0x42, 0x55, 0x3a, 0x84, 0xdd, 0xaa, 0x8e, 0x8a, 0x59, 0x95, 0xc7, 0x85, 0xaa, 0xe2, 0x69,
   0x46, 0xbf, 0x9a, 0xbd, 0x0b, 0xa3, 0x5a, 0x49, 0x1d, 0xce, 0x77, 0x2b, 0x33, 0x0a, 0x3f, 0x55,
   0x32, 0x26, 0x36, 0xfb, 0xc0, 0x55, 0xf0, 0xc5, 0xee, 0x58, 0xd2, 0xa8, 0xbc, 0x53, 0xc7, 0xa3,
   0xaf, 0x3c, 0x58, 0xf6, 0x18, 0xd7, 0xec, 0x81, 0xba, 0x2f, 0xca, 0x6c, 0xd3, 0xfd, 0xa3, 0xc0,
   0x27, 0x84, 0x1e, 0x8a, 0x33, 0x23, 0xb1, 0xb9, 0xda, 0x36, 0x33, 0x23, 0x02, 0x58, 0x87, 0xbb,
   0x25, 0x7d, 0xf4, 0x5d, 0x4d, 0xef, 0xf8, 0x05, 0x4d, 0x2f, 0xfd, 0x7f, 0x25, 0x85, 0xad, 0xa4,
   0x13, 0x3b, 0xac, 0xd7, 0x52, 0x98, 0xf8, 0x8d, 0x60, 0x49, 0x41, 0x92, 0x94, 0xb5, 0x3e, 0x4f,
   0xec, 0x1f, 0x7f, 0x7e, 0x3c, 0x17, 0xee, 0x45, 0xab, 0x34, 0x7a, 0x0a, 0xd0, 0xaa, 0x13, 0xaf,
   0xeb, 0xfe, 0xd2, 0x2a, 0x5d, 0x9a, 0x36, 0xc0, 0xaa, 0xfd, 0x2b, 0x6f, 0xd0, 0xf9, 0x2b, 0xef,
   0x65, 0x43, 0xd5, 0x47, 0x30, 0xb5, 0x8a, 0x77, 0x3d, 0xa8, 0xd7, 0xf6, 0xa0, 0x2f, 0x69, 0xe5,
   0xa2, 0xbf, 0x7b, 0x70, 0xeb, 0xb1, 0x3e, 0x16, 0x4a, 0x17, 0xf9, 0x43, 0xbe, 0x39, 0xb7, 0x55,
   0x99, 0xbd, 0x6f, 0xb3, 0xb7, 0x49, 0x0a, 0x9d, 0x40, 0x7a, 0xac, 0x3b, 0x62, 0xa9, 0x2d, 0x50,
   0x6f, 0xd8, 0x3c, 0x6e, 0x0a, 0xe9, 0xb0, 0x09, 0x69, 0x33, 0xdc, 0x94, 0xb4, 0x7b, 0x67, 0xb8,
   0x31, 0xc0, 0x8a, 0x32, 0xc1, 0x99, 0xcd, 0xd9, 0x36, 0x4a, 0x2c, 0xd9, 0xa9, 0xfe, 0xe3, 0xef,
   0xac, 0xfe, 0xfd, 0xff, 0xbe, 0xc6, 0xee, 0x6d, 0xf7, 0xff, 0xec, 0xc1, 0xa2, 0xdb, 0x69, 0xb0,
   0x05, 0xcc, 0x4e, 0x13, 0xd3, 0x13, 0x04, 0x7b, 0x2c, 0x80, 0x85, 0xa3, 0xb0, 0x19, 0x0e, 0x3c,
   0x76, 0x1b, 0x82, 0x2e, 0x82, 0x25, 0x2a, 0x18, 0x30, 0x80, 0xc9, 0x69, 0x42, 0x12, 0x43, 0xb6,
   0x04, 0xdf, 0xac, 0x4f, 0xd2, 0x8b, 0x60, 0xc4, 0x6e, 0xc2, 0xb2, 0x21, 0xd1, 0x55, 0x83, 0x31,
   0xf3, 0x61, 0x7c, 0x9a, 0x20, 0x77, 0xc2, 0x6e, 0xc1, 0x0d, 0xb7, 0x9d, 0x6d, 0x41, 0x82, 0x29,
   0xdb, 0x07, 0x38, 0x4d, 0x4e, 0xed, 0x5f, 0x18, 0xc1, 0xcc, 0xdc, 0xc9, 0x24, 0xe8, 0xc0, 0x37,
   0x77, 0x3a, 0x2e, 0xa4, 0x7c, 0x58, 0xe4, 0x67, 0xd9, 0x36, 0x80, 0xfb, 0x1f, 0xc2, 0xcc, 0x3d,
   0x18, 0x6f, 0xb2, 0xca, 0xb5, 0x50, 0x55, 0xb0, 0x87, 0xeb, 0xa7, 0x34, 0x20, 0x04, 0x1e, 0xae,
   0x1f, 0x09, 0x29, 0x2a, 0x11, 0x0c, 0xee, 0x1f, 0x41, 0xb0, 0x9b, 0xb7, 0xd9, 0x0d, 0x98, 0xc7,
   0x62, 0x95, 0x67, 0x15, 0x99, 0x2e, 0xd8, 0x43, 0xc0, 0x7c, 0x6c, 0x00, 0x8f, 0xcd, 0x61, 0x6a,
   0xbf, 0x0a, 0x06, 0xf7, 0x3f, 0x86, 0xfd, 0xbe, 0x95, 0xcd, 0xb3, 0x1f, 0xad, 0x49, 0x99, 0xc1,
   0x9e, 0x79, 0x98, 0x25, 0x8d, 0xeb, 0x04, 0xde, 0x27, 0xe1, 0x5f, 0xbe, 0x3e, 0xf0, 0xbe, 0xfc,
   0xfa, 0xc0, 0xfb, 0xc7, 0xd7, 0x07, 0xde, 0x1f, 0xbe, 0x39, 0xd8, 0xfb, 0xf2, 0x9b, 0x83, 0xbd,
   0xbf, 0x7d, 0x73, 0xb0, 0xb7, 0x9e, 0x90, 0xe9, 0x3e, 0xfa, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff,
   0x2b, 0x7f, 0x1d, 0xa7, 0x0c, 0x18, 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) {
@@ -3098,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
@@ -3196,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
}
@@ -3462,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
@@ -4368,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 {
@@ -4384,7 +4574,7 @@
      }
   }
   if m.Type != 0 {
      dAtA[i] = 0x30
      dAtA[i] = 0x38
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
   }
@@ -4479,22 +4669,10 @@
      }
   }
   if len(m.AlarmLevel) > 0 {
      dAtA5 := make([]byte, len(m.AlarmLevel)*10)
      var j4 int
      for _, num1 := range m.AlarmLevel {
         num := uint64(num1)
         for num >= 1<<7 {
            dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
            num >>= 7
            j4++
         }
         dAtA5[j4] = uint8(num)
         j4++
      }
      dAtA[i] = 0x3a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(j4))
      i += copy(dAtA[i:], dAtA5[:j4])
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.AlarmLevel)))
      i += copy(dAtA[i:], m.AlarmLevel)
   }
   if len(m.SearchTime) > 0 {
      for _, s := range m.SearchTime {
@@ -4886,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)
@@ -5003,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 {
@@ -5051,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
}
@@ -5185,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 {
@@ -5687,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)
@@ -5736,12 +5991,9 @@
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   if len(m.AlarmLevel) > 0 {
      l = 0
      for _, e := range m.AlarmLevel {
         l += sovProtomsg(uint64(e))
      }
      n += 1 + sovProtomsg(uint64(l)) + l
   l = len(m.AlarmLevel)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.SearchTime) > 0 {
      for _, s := range m.SearchTime {
@@ -5947,6 +6199,39 @@
   }
   if m.Enable {
      n += 2
   }
   return n
}

func (m *PushAttach) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.PushId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.Cam != nil {
      l = m.Cam.Size()
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.ServerId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.ServerName)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.LocalIp)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.VideoUrl)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}
@@ -6321,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)
         }
@@ -6350,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)
         }
@@ -6361,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)
@@ -6662,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
@@ -7575,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
@@ -7585,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 {
@@ -11068,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
@@ -11098,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)
         }
@@ -11344,81 +11776,37 @@
         m.Tabs = append(m.Tabs, string(dAtA[iNdEx:postIndex]))
         iNdEx = postIndex
      case 7:
         if wireType == 0 {
            var v int32
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return ErrIntOverflowProtomsg
               }
               if iNdEx >= l {
                  return io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               v |= int32(b&0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            m.AlarmLevel = append(m.AlarmLevel, v)
         } else if wireType == 2 {
            var packedLen int
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return ErrIntOverflowProtomsg
               }
               if iNdEx >= l {
                  return io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               packedLen |= int(b&0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            if packedLen < 0 {
               return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + packedLen
            if postIndex < 0 {
               return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
               return io.ErrUnexpectedEOF
            }
            var elementCount int
            var count int
            for _, integer := range dAtA[iNdEx:postIndex] {
               if integer < 128 {
                  count++
               }
            }
            elementCount = count
            if elementCount != 0 && len(m.AlarmLevel) == 0 {
               m.AlarmLevel = make([]int32, 0, elementCount)
            }
            for iNdEx < postIndex {
               var v int32
               for shift := uint(0); ; shift += 7 {
                  if shift >= 64 {
                     return ErrIntOverflowProtomsg
                  }
                  if iNdEx >= l {
                     return io.ErrUnexpectedEOF
                  }
                  b := dAtA[iNdEx]
                  iNdEx++
                  v |= int32(b&0x7F) << shift
                  if b < 0x80 {
                     break
                  }
               }
               m.AlarmLevel = append(m.AlarmLevel, v)
            }
         } else {
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AlarmLevel", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AlarmLevel = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SearchTime", wireType)
@@ -12837,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