update

zhangmeng

2019-06-16 8a2b616a4e38ba4af404937482368ad3f6392fb9

 protomsg.pb.go

@@ -824,10 +824,9 @@

//摄像机布防的时间规则，可以设置多个,用id关联到具体的规则配置中
type CameraTimerule struct {
   Id       string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Name     string    `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   CameraId string    `protobuf:"bytes,3,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   TimeRule []*DayCtl `protobuf:"bytes,4,rep,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
   Id       string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Name     string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   TimeRule string `protobuf:"bytes,3,opt,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
}

func (m *CameraTimerule) Reset()         { *m = CameraTimerule{} }
@@ -877,18 +876,11 @@
   return ""
}

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

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

//DayCtl struct   每天的时间控制规则
@@ -1001,7 +993,7 @@
type Polygon struct {
   Id     string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Name   string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
   Points []*Point `protobuf:"bytes,4,rep,name=points,proto3" json:"points,omitempty"`
   Points []*Point `protobuf:"bytes,3,rep,name=points,proto3" json:"points,omitempty"`
}

func (m *Polygon) Reset()         { *m = Polygon{} }
@@ -1059,18 +1051,8 @@
}

type CameraTaskArgs struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraTaskId string `protobuf:"bytes,2,opt,name=camera_task_id,json=cameraTaskId,proto3" json:"camera_task_id,omitempty"`
   CameraId     string `protobuf:"bytes,3,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   PolygonId    string `protobuf:"bytes,4,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
   SdkId        string `protobuf:"bytes,5,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
   SdkArgAlias  string `protobuf:"bytes,6,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator     string `protobuf:"bytes,7,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,8,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   SdkArgValue  string `protobuf:"bytes,9,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort         int32  `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
   RuleWithNext string `protobuf:"bytes,11,opt,name=rule_with_next,json=ruleWithNext,proto3" json:"rule_with_next,omitempty"`
   GroupId      string `protobuf:"bytes,12,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   CameraId string           `protobuf:"bytes,1,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   TaskArgs []*TaskGroupArgs `protobuf:"bytes,2,rep,name=task_args,json=taskArgs,proto3" json:"task_args,omitempty"`
}

func (m *CameraTaskArgs) Reset()         { *m = CameraTaskArgs{} }
@@ -1106,20 +1088,6 @@

var xxx_messageInfo_CameraTaskArgs proto.InternalMessageInfo

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

func (m *CameraTaskArgs) GetCameraTaskId() string {
   if m != nil {
      return m.CameraTaskId
   }
   return ""
}

func (m *CameraTaskArgs) GetCameraId() string {
   if m != nil {
      return m.CameraId
@@ -1127,63 +1095,243 @@
   return ""
}

func (m *CameraTaskArgs) GetPolygonId() string {
func (m *CameraTaskArgs) GetTaskArgs() []*TaskGroupArgs {
   if m != nil {
      return m.TaskArgs
   }
   return nil
}

type TaskGroupArgs struct {
   TaskId     string       `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
   GroupRules []*GroupRule `protobuf:"bytes,2,rep,name=group_rules,json=groupRules,proto3" json:"group_rules,omitempty"`
}

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

var xxx_messageInfo_TaskGroupArgs proto.InternalMessageInfo

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

func (m *TaskGroupArgs) GetGroupRules() []*GroupRule {
   if m != nil {
      return m.GroupRules
   }
   return nil
}

type GroupRule struct {
   GroupId string  `protobuf:"bytes,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
   Rules   []*Rule `protobuf:"bytes,2,rep,name=rules,proto3" json:"rules,omitempty"`
}

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

var xxx_messageInfo_GroupRule proto.InternalMessageInfo

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

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

type Rule struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   CameraTaskId string `protobuf:"bytes,2,opt,name=camera_task_id,json=cameraTaskId,proto3" json:"camera_task_id,omitempty"`
   CameraId     string `protobuf:"bytes,3,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
   PolygonId    string `protobuf:"bytes,4,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
   SdkId        string `protobuf:"bytes,5,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
   SdkArgAlias  string `protobuf:"bytes,6,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
   Operator     string `protobuf:"bytes,7,opt,name=operator,proto3" json:"operator,omitempty"`
   OperatorType string `protobuf:"bytes,8,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
   SdkArgValue  string `protobuf:"bytes,9,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
   Sort         int32  `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
   RuleWithPre  string `protobuf:"bytes,11,opt,name=rule_with_pre,json=ruleWithPre,proto3" json:"rule_with_pre,omitempty"`
   GroupId      string `protobuf:"bytes,12,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
}

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

var xxx_messageInfo_Rule proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

func (m *CameraTaskArgs) GetRuleWithNext() string {
func (m *Rule) GetRuleWithPre() string {
   if m != nil {
      return m.RuleWithNext
      return m.RuleWithPre
   }
   return ""
}

func (m *CameraTaskArgs) GetGroupId() string {
func (m *Rule) GetGroupId() string {
   if m != nil {
      return m.GroupId
   }
@@ -1209,7 +1357,7 @@
func (m *Sdk) String() string { return proto.CompactTextString(m) }
func (*Sdk) ProtoMessage()    {}
func (*Sdk) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{14}
   return fileDescriptor_32de24555f916688, []int{17}
}
func (m *Sdk) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1329,7 +1477,7 @@
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{15}
   return fileDescriptor_32de24555f916688, []int{18}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1410,7 +1558,7 @@
func (m *Point) String() string { return proto.CompactTextString(m) }
func (*Point) ProtoMessage()    {}
func (*Point) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{16}
   return fileDescriptor_32de24555f916688, []int{19}
}
func (m *Point) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1464,7 +1612,7 @@
func (m *Rect) String() string { return proto.CompactTextString(m) }
func (*Rect) ProtoMessage()    {}
func (*Rect) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{17}
   return fileDescriptor_32de24555f916688, []int{20}
}
func (m *Rect) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1532,7 +1680,7 @@
func (m *FaceAngle) String() string { return proto.CompactTextString(m) }
func (*FaceAngle) ProtoMessage()    {}
func (*FaceAngle) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{18}
   return fileDescriptor_32de24555f916688, []int{21}
}
func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1601,7 +1749,7 @@
func (m *ThftResult) String() string { return proto.CompactTextString(m) }
func (*ThftResult) ProtoMessage()    {}
func (*ThftResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{19}
   return fileDescriptor_32de24555f916688, []int{22}
}
func (m *ThftResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1680,7 +1828,7 @@
func (m *FacePos) String() string { return proto.CompactTextString(m) }
func (*FacePos) ProtoMessage()    {}
func (*FacePos) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{20}
   return fileDescriptor_32de24555f916688, []int{23}
}
func (m *FacePos) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1781,7 +1929,7 @@
func (m *FaceInfo) String() string { return proto.CompactTextString(m) }
func (*FaceInfo) ProtoMessage()    {}
func (*FaceInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{21}
   return fileDescriptor_32de24555f916688, []int{24}
}
func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1883,7 +2031,7 @@
func (m *ObjInfo) String() string { return proto.CompactTextString(m) }
func (*ObjInfo) ProtoMessage()    {}
func (*ObjInfo) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{22}
   return fileDescriptor_32de24555f916688, []int{25}
}
func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1943,7 +2091,7 @@
func (m *ParamFacePos) String() string { return proto.CompactTextString(m) }
func (*ParamFacePos) ProtoMessage()    {}
func (*ParamFacePos) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{23}
   return fileDescriptor_32de24555f916688, []int{26}
}
func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1996,7 +2144,7 @@
func (m *ParamFaceCompare) String() string { return proto.CompactTextString(m) }
func (*ParamFaceCompare) ProtoMessage()    {}
func (*ParamFaceCompare) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{24}
   return fileDescriptor_32de24555f916688, []int{27}
}
func (m *ParamFaceCompare) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2049,7 +2197,7 @@
func (m *ParamFaceProperty) String() string { return proto.CompactTextString(m) }
func (*ParamFaceProperty) ProtoMessage()    {}
func (*ParamFaceProperty) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{25}
   return fileDescriptor_32de24555f916688, []int{28}
}
func (m *ParamFaceProperty) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2102,7 +2250,7 @@
func (m *ParamYoloObj) String() string { return proto.CompactTextString(m) }
func (*ParamYoloObj) ProtoMessage()    {}
func (*ParamYoloObj) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{26}
   return fileDescriptor_32de24555f916688, []int{29}
}
func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2157,7 +2305,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
   return fileDescriptor_32de24555f916688, []int{27}
   return fileDescriptor_32de24555f916688, []int{30}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -2214,6 +2362,106 @@
   return ""
}

type CameraPolygon 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"`
   Name          string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
   Polygon       string `protobuf:"bytes,4,opt,name=polygon,proto3" json:"polygon,omitempty"`
   TriggerLine   string `protobuf:"bytes,5,opt,name=trigger_line,json=triggerLine,proto3" json:"trigger_line,omitempty"`
   DirectionLine string `protobuf:"bytes,6,opt,name=direction_line,json=directionLine,proto3" json:"direction_line,omitempty"`
   Type          string `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
   DefenceState  int32  `protobuf:"varint,8,opt,name=defence_state,json=defenceState,proto3" json:"defence_state,omitempty"`
}

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

var xxx_messageInfo_CameraPolygon proto.InternalMessageInfo

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

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

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

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

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

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

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

func (m *CameraPolygon) GetDefenceState() int32 {
   if m != nil {
      return m.DefenceState
   }
   return 0
}

func init() {
   proto.RegisterEnum("protomsg.TableChanged", TableChanged_name, TableChanged_value)
   proto.RegisterEnum("protomsg.DbAction", DbAction_name, DbAction_value)
@@ -2231,6 +2479,9 @@
   proto.RegisterType((*TimeRange)(nil), "protomsg.TimeRange")
   proto.RegisterType((*Polygon)(nil), "protomsg.Polygon")
   proto.RegisterType((*CameraTaskArgs)(nil), "protomsg.CameraTaskArgs")
   proto.RegisterType((*TaskGroupArgs)(nil), "protomsg.TaskGroupArgs")
   proto.RegisterType((*GroupRule)(nil), "protomsg.GroupRule")
   proto.RegisterType((*Rule)(nil), "protomsg.Rule")
   proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
   proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
   proto.RegisterType((*Point)(nil), "protomsg.Point")
@@ -2245,125 +2496,136 @@
   proto.RegisterType((*ParamFaceProperty)(nil), "protomsg.ParamFaceProperty")
   proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
   proto.RegisterType((*DbChangeMessage)(nil), "protomsg.DbChangeMessage")
   proto.RegisterType((*CameraPolygon)(nil), "protomsg.CameraPolygon")
}

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

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

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
@@ -2913,23 +3175,11 @@
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
      i += copy(dAtA[i:], m.Name)
   }
   if len(m.CameraId) > 0 {
   if len(m.TimeRule) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
      i += copy(dAtA[i:], m.CameraId)
   }
   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
      }
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeRule)))
      i += copy(dAtA[i:], m.TimeRule)
   }
   return i, nil
}
@@ -3028,7 +3278,7 @@
   }
   if len(m.Points) > 0 {
      for _, msg := range m.Points {
         dAtA[i] = 0x22
         dAtA[i] = 0x1a
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
@@ -3052,6 +3302,114 @@
}

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

func (m *TaskGroupArgs) 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 *TaskGroupArgs) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.TaskId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TaskId)))
      i += copy(dAtA[i:], m.TaskId)
   }
   if len(m.GroupRules) > 0 {
      for _, msg := range m.GroupRules {
         dAtA[i] = 0x12
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *GroupRule) 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 *GroupRule) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.GroupId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
      i += copy(dAtA[i:], m.GroupId)
   }
   if len(m.Rules) > 0 {
      for _, msg := range m.Rules {
         dAtA[i] = 0x12
         i++
         i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *Rule) 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 *Rule) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -3115,11 +3473,11 @@
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
   }
   if len(m.RuleWithNext) > 0 {
   if len(m.RuleWithPre) > 0 {
      dAtA[i] = 0x5a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithNext)))
      i += copy(dAtA[i:], m.RuleWithNext)
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithPre)))
      i += copy(dAtA[i:], m.RuleWithPre)
   }
   if len(m.GroupId) > 0 {
      dAtA[i] = 0x62
@@ -3833,6 +4191,71 @@
   return i, nil
}

func (m *CameraPolygon) 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 *CameraPolygon) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.CameraId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
      i += copy(dAtA[i:], m.CameraId)
   }
   if len(m.Name) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
      i += copy(dAtA[i:], m.Name)
   }
   if len(m.Polygon) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Polygon)))
      i += copy(dAtA[i:], m.Polygon)
   }
   if len(m.TriggerLine) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TriggerLine)))
      i += copy(dAtA[i:], m.TriggerLine)
   }
   if len(m.DirectionLine) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.DirectionLine)))
      i += copy(dAtA[i:], m.DirectionLine)
   }
   if len(m.Type) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Type)))
      i += copy(dAtA[i:], m.Type)
   }
   if m.DefenceState != 0 {
      dAtA[i] = 0x40
      i++
      i = encodeVarintProtomsg(dAtA, i, uint64(m.DefenceState))
   }
   return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -4127,15 +4550,9 @@
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.CameraId)
   l = len(m.TimeRule)
   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))
      }
   }
   return n
}
@@ -4204,6 +4621,63 @@
   }
   var l int
   _ = l
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if len(m.TaskArgs) > 0 {
      for _, e := range m.TaskArgs {
         l = e.Size()
         n += 1 + l + sovProtomsg(uint64(l))
      }
   }
   return n
}

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

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

func (m *Rule) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
@@ -4243,7 +4717,7 @@
   if m.Sort != 0 {
      n += 1 + sovProtomsg(uint64(m.Sort))
   }
   l = len(m.RuleWithNext)
   l = len(m.RuleWithPre)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
@@ -4612,6 +5086,46 @@
   l = len(m.Info)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   return n
}

func (m *CameraPolygon) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Name)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Polygon)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.TriggerLine)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.DirectionLine)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   l = len(m.Type)
   if l > 0 {
      n += 1 + l + sovProtomsg(uint64(l))
   }
   if m.DefenceState != 0 {
      n += 1 + sovProtomsg(uint64(m.DefenceState))
   }
   return n
}
@@ -6580,7 +7094,7 @@
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
            return fmt.Errorf("proto: wrong wireType = %d for field TimeRule", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
@@ -6608,41 +7122,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TimeRule", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.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
      default:
         iNdEx = preIndex
@@ -6984,7 +7464,7 @@
         }
         m.Name = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Points", wireType)
         }
@@ -7069,6 +7549,363 @@
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraTaskArgs: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TaskArgs", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.TaskArgs = append(m.TaskArgs, &TaskGroupArgs{})
         if err := m.TaskArgs[len(m.TaskArgs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *GroupRule) 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: GroupRule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: GroupRule: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field GroupId", 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.GroupId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Rules = append(m.Rules, &Rule{})
         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *Rule) 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: Rule: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -7380,7 +8217,7 @@
         }
      case 11:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RuleWithNext", wireType)
            return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
@@ -7408,7 +8245,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.RuleWithNext = string(dAtA[iNdEx:postIndex])
         m.RuleWithPre = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 12:
         if wireType != 2 {
@@ -10013,6 +10850,302 @@
   }
   return nil
}
func (m *CameraPolygon) 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: CameraPolygon: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: CameraPolygon: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthProtomsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthProtomsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Name = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Polygon", 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.Polygon = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TriggerLine", 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.TriggerLine = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field DirectionLine", 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.DirectionLine = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Type", 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.Type = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field DefenceState", wireType)
         }
         m.DefenceState = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.DefenceState |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipProtomsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthProtomsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

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