fix CameraRules

liuxiaolong

2020-06-23 5c98f1cb4f72f944f775638db5377725bdfd2c46

fix CameraRules

 protomsg.pb.go

@@ -880,23 +880,25 @@
    return nil
}

type CameraRules struct {
    CameraId string       `protobuf:"bytes,1,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
    Rules    []*GroupRule `protobuf:"bytes,2,rep,name=rules,proto3" json:"rules,omitempty"`
type CameraInfo struct {
    RunServerName string `protobuf:"bytes,1,opt,name=runServerName,proto3" json:"runServerName,omitempty"`
    Id            string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
    Name          string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
    RunType       int32  `protobuf:"varint,4,opt,name=run_type,json=runType,proto3" json:"run_type,omitempty"`
}

func (m *CameraRules) Reset()         { *m = CameraRules{} }
func (m *CameraRules) String() string { return proto.CompactTextString(m) }
func (*CameraRules) ProtoMessage()    {}
func (*CameraRules) Descriptor() ([]byte, []int) {
func (m *CameraInfo) Reset()         { *m = CameraInfo{} }
func (m *CameraInfo) String() string { return proto.CompactTextString(m) }
func (*CameraInfo) ProtoMessage()    {}
func (*CameraInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{9}
}
func (m *CameraRules) XXX_Unmarshal(b []byte) error {
func (m *CameraInfo) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *CameraRules) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *CameraInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_CameraRules.Marshal(b, m, deterministic)
        return xxx_messageInfo_CameraInfo.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
@@ -906,26 +908,92 @@
        return b[:n], nil
    }
}
func (m *CameraRules) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CameraRules.Merge(m, src)
func (m *CameraInfo) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CameraInfo.Merge(m, src)
}
func (m *CameraRules) XXX_Size() int {
func (m *CameraInfo) XXX_Size() int {
    return m.Size()
}
func (m *CameraRules) XXX_DiscardUnknown() {
    xxx_messageInfo_CameraRules.DiscardUnknown(m)
func (m *CameraInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_CameraInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CameraRules proto.InternalMessageInfo
var xxx_messageInfo_CameraInfo proto.InternalMessageInfo

func (m *CameraRules) GetCameraId() string {
func (m *CameraInfo) GetRunServerName() string {
    if m != nil {
        return m.CameraId
        return m.RunServerName
    }
    return ""
}

func (m *CameraRules) GetRules() []*GroupRule {
func (m *CameraInfo) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

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

func (m *CameraInfo) GetRunType() int32 {
    if m != nil {
        return m.RunType
    }
    return 0
}

type CameraAndRules struct {
    CameraInfo *CameraInfo  `protobuf:"bytes,1,opt,name=cameraInfo,proto3" json:"cameraInfo,omitempty"`
    Rules      []*GroupRule `protobuf:"bytes,2,rep,name=rules,proto3" json:"rules,omitempty"`
}

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

var xxx_messageInfo_CameraAndRules proto.InternalMessageInfo

func (m *CameraAndRules) GetCameraInfo() *CameraInfo {
    if m != nil {
        return m.CameraInfo
    }
    return nil
}

func (m *CameraAndRules) GetRules() []*GroupRule {
    if m != nil {
        return m.Rules
    }
@@ -933,24 +1001,25 @@
}

type GroupRule struct {
    GroupId      string  `protobuf:"bytes,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
    GroupText    string  `protobuf:"bytes,2,opt,name=group_text,json=groupText,proto3" json:"group_text,omitempty"`
    AlarmLevel   int32   `protobuf:"varint,3,opt,name=alarm_level,json=alarmLevel,proto3" json:"alarm_level,omitempty"`
    Rules        []*Rule `protobuf:"bytes,4,rep,name=rules,proto3" json:"rules,omitempty"`
    SetType      string  `protobuf:"bytes,5,opt,name=set_type,json=setType,proto3" json:"set_type,omitempty"`
    TemplateId   string  `protobuf:"bytes,6,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
    TemplateRule string  `protobuf:"bytes,7,opt,name=template_rule,json=templateRule,proto3" json:"template_rule,omitempty"`
    TimeRuleId   string  `protobuf:"bytes,8,opt,name=time_rule_id,json=timeRuleId,proto3" json:"time_rule_id,omitempty"`
    SceneName    string  `protobuf:"bytes,9,opt,name=scene_name,json=sceneName,proto3" json:"scene_name,omitempty"`
    Desc         string  `protobuf:"bytes,10,opt,name=desc,proto3" json:"desc,omitempty"`
    Enable       bool    `protobuf:"varint,11,opt,name=enable,proto3" json:"enable,omitempty"`
    CameraIds    []string `protobuf:"bytes,1,rep,name=cameraIds,proto3" json:"cameraIds,omitempty"`
    Id           string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
    GroupText    string   `protobuf:"bytes,3,opt,name=group_text,json=groupText,proto3" json:"group_text,omitempty"`
    AlarmLevel   int32    `protobuf:"varint,4,opt,name=alarm_level,json=alarmLevel,proto3" json:"alarm_level,omitempty"`
    Rules        []*Rule  `protobuf:"bytes,5,rep,name=rules,proto3" json:"rules,omitempty"`
    SetType      string   `protobuf:"bytes,6,opt,name=set_type,json=setType,proto3" json:"set_type,omitempty"`
    TemplateId   string   `protobuf:"bytes,7,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
    TemplateRule string   `protobuf:"bytes,8,opt,name=template_rule,json=templateRule,proto3" json:"template_rule,omitempty"`
    TimeRuleId   string   `protobuf:"bytes,9,opt,name=time_rule_id,json=timeRuleId,proto3" json:"time_rule_id,omitempty"`
    SceneName    string   `protobuf:"bytes,10,opt,name=scene_name,json=sceneName,proto3" json:"scene_name,omitempty"`
    Desc         string   `protobuf:"bytes,11,opt,name=desc,proto3" json:"desc,omitempty"`
    Enable       bool     `protobuf:"varint,12,opt,name=enable,proto3" json:"enable,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{10}
    return fileDescriptor_32de24555f916688, []int{11}
}
func (m *GroupRule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -979,9 +1048,16 @@

var xxx_messageInfo_GroupRule proto.InternalMessageInfo

func (m *GroupRule) GetGroupId() string {
func (m *GroupRule) GetCameraIds() []string {
    if m != nil {
        return m.GroupId
        return m.CameraIds
    }
    return nil
}

func (m *GroupRule) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}
@@ -1074,7 +1150,7 @@
func (m *Rule) String() string { return proto.CompactTextString(m) }
func (*Rule) ProtoMessage()    {}
func (*Rule) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{11}
    return fileDescriptor_32de24555f916688, []int{12}
}
func (m *Rule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1192,7 +1268,7 @@
func (m *RuleTemplate) String() string { return proto.CompactTextString(m) }
func (*RuleTemplate) ProtoMessage()    {}
func (*RuleTemplate) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{12}
    return fileDescriptor_32de24555f916688, []int{13}
}
func (m *RuleTemplate) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1269,7 +1345,7 @@
func (m *TemplateArg) String() string { return proto.CompactTextString(m) }
func (*TemplateArg) ProtoMessage()    {}
func (*TemplateArg) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{13}
    return fileDescriptor_32de24555f916688, []int{14}
}
func (m *TemplateArg) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1362,7 +1438,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{15}
}
func (m *Sdk) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1506,7 +1582,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{16}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1609,7 +1685,7 @@
func (m *SdkChanSet) String() string { return proto.CompactTextString(m) }
func (*SdkChanSet) ProtoMessage()    {}
func (*SdkChanSet) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{16}
    return fileDescriptor_32de24555f916688, []int{17}
}
func (m *SdkChanSet) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1678,7 +1754,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{17}
    return fileDescriptor_32de24555f916688, []int{18}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1750,7 +1826,7 @@
func (m *CameraPolygon) String() string { return proto.CompactTextString(m) }
func (*CameraPolygon) ProtoMessage()    {}
func (*CameraPolygon) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{18}
    return fileDescriptor_32de24555f916688, []int{19}
}
func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1849,7 +1925,7 @@
func (m *VideotapeInfo) String() string { return proto.CompactTextString(m) }
func (*VideotapeInfo) ProtoMessage()    {}
func (*VideotapeInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{19}
    return fileDescriptor_32de24555f916688, []int{20}
}
func (m *VideotapeInfo) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1947,7 +2023,7 @@
func (m *CompareArgs) String() string { return proto.CompactTextString(m) }
func (*CompareArgs) ProtoMessage()    {}
func (*CompareArgs) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{20}
    return fileDescriptor_32de24555f916688, []int{21}
}
func (m *CompareArgs) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2076,7 +2152,7 @@
func (m *CompareEvent) String() string { return proto.CompactTextString(m) }
func (*CompareEvent) ProtoMessage()    {}
func (*CompareEvent) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{21}
    return fileDescriptor_32de24555f916688, []int{22}
}
func (m *CompareEvent) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2129,7 +2205,7 @@
func (m *SdkCompareEach) String() string { return proto.CompactTextString(m) }
func (*SdkCompareEach) ProtoMessage()    {}
func (*SdkCompareEach) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{22}
    return fileDescriptor_32de24555f916688, []int{23}
}
func (m *SdkCompareEach) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2187,7 +2263,7 @@
func (m *SdkCompareResult) String() string { return proto.CompactTextString(m) }
func (*SdkCompareResult) ProtoMessage()    {}
func (*SdkCompareResult) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{23}
    return fileDescriptor_32de24555f916688, []int{24}
}
func (m *SdkCompareResult) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2242,7 +2318,7 @@
func (m *EventPush) String() string { return proto.CompactTextString(m) }
func (*EventPush) ProtoMessage()    {}
func (*EventPush) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{24}
    return fileDescriptor_32de24555f916688, []int{25}
}
func (m *EventPush) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2369,7 +2445,7 @@
func (m *EventPushRule) String() string { return proto.CompactTextString(m) }
func (*EventPushRule) ProtoMessage()    {}
func (*EventPushRule) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{25}
    return fileDescriptor_32de24555f916688, []int{26}
}
func (m *EventPushRule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2457,7 +2533,7 @@
func (m *PushIpPort) String() string { return proto.CompactTextString(m) }
func (*PushIpPort) ProtoMessage()    {}
func (*PushIpPort) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{26}
    return fileDescriptor_32de24555f916688, []int{27}
}
func (m *PushIpPort) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2516,7 +2592,7 @@
func (m *PushUrl) String() string { return proto.CompactTextString(m) }
func (*PushUrl) ProtoMessage()    {}
func (*PushUrl) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{27}
    return fileDescriptor_32de24555f916688, []int{28}
}
func (m *PushUrl) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2572,7 +2648,7 @@
func (m *PushAttach) String() string { return proto.CompactTextString(m) }
func (*PushAttach) ProtoMessage()    {}
func (*PushAttach) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{28}
    return fileDescriptor_32de24555f916688, []int{29}
}
func (m *PushAttach) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2657,7 +2733,7 @@
func (m *EsPersonCacheChange) String() string { return proto.CompactTextString(m) }
func (*EsPersonCacheChange) ProtoMessage()    {}
func (*EsPersonCacheChange) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{29}
    return fileDescriptor_32de24555f916688, []int{30}
}
func (m *EsPersonCacheChange) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -2749,7 +2825,8 @@
    proto.RegisterType((*DayCtl)(nil), "protomsg.DayCtl")
    proto.RegisterType((*TimeRange)(nil), "protomsg.TimeRange")
    proto.RegisterType((*Polygon)(nil), "protomsg.Polygon")
    proto.RegisterType((*CameraRules)(nil), "protomsg.CameraRules")
    proto.RegisterType((*CameraInfo)(nil), "protomsg.CameraInfo")
    proto.RegisterType((*CameraAndRules)(nil), "protomsg.CameraAndRules")
    proto.RegisterType((*GroupRule)(nil), "protomsg.GroupRule")
    proto.RegisterType((*Rule)(nil), "protomsg.Rule")
    proto.RegisterType((*RuleTemplate)(nil), "protomsg.RuleTemplate")
@@ -2775,166 +2852,168 @@
func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

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

func (m *Area) Marshal() (dAtA []byte, err error) {
@@ -3429,7 +3508,7 @@
    return i, nil
}

func (m *CameraRules) Marshal() (dAtA []byte, err error) {
func (m *CameraInfo) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
@@ -3439,16 +3518,61 @@
    return dAtA[:n], nil
}

func (m *CameraRules) MarshalTo(dAtA []byte) (int, error) {
func (m *CameraInfo) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.CameraId) > 0 {
    if len(m.RunServerName) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
        i += copy(dAtA[i:], m.CameraId)
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RunServerName)))
        i += copy(dAtA[i:], m.RunServerName)
    }
    if len(m.Id) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
        i += copy(dAtA[i:], m.Id)
    }
    if len(m.Name) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
        i += copy(dAtA[i:], m.Name)
    }
    if m.RunType != 0 {
        dAtA[i] = 0x20
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.RunType))
    }
    return i, nil
}

func (m *CameraAndRules) 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 *CameraAndRules) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.CameraInfo != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.CameraInfo.Size()))
        n1, err1 := m.CameraInfo.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        }
        i += n1
    }
    if len(m.Rules) > 0 {
        for _, msg := range m.Rules {
@@ -3480,26 +3604,41 @@
    _ = i
    var l int
    _ = l
    if len(m.GroupId) > 0 {
    if len(m.CameraIds) > 0 {
        for _, s := range m.CameraIds {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
        i += copy(dAtA[i:], m.GroupId)
            l = len(s)
            for l >= 1<<7 {
                dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
                l >>= 7
                i++
            }
            dAtA[i] = uint8(l)
            i++
            i += copy(dAtA[i:], s)
        }
    }
    if len(m.Id) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
        i += copy(dAtA[i:], m.Id)
    }
    if len(m.GroupText) > 0 {
        dAtA[i] = 0x12
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupText)))
        i += copy(dAtA[i:], m.GroupText)
    }
    if m.AlarmLevel != 0 {
        dAtA[i] = 0x18
        dAtA[i] = 0x20
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.AlarmLevel))
    }
    if len(m.Rules) > 0 {
        for _, msg := range m.Rules {
            dAtA[i] = 0x22
            dAtA[i] = 0x2a
            i++
            i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
@@ -3510,43 +3649,43 @@
        }
    }
    if len(m.SetType) > 0 {
        dAtA[i] = 0x2a
        dAtA[i] = 0x32
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SetType)))
        i += copy(dAtA[i:], m.SetType)
    }
    if len(m.TemplateId) > 0 {
        dAtA[i] = 0x32
        dAtA[i] = 0x3a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TemplateId)))
        i += copy(dAtA[i:], m.TemplateId)
    }
    if len(m.TemplateRule) > 0 {
        dAtA[i] = 0x3a
        dAtA[i] = 0x42
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TemplateRule)))
        i += copy(dAtA[i:], m.TemplateRule)
    }
    if len(m.TimeRuleId) > 0 {
        dAtA[i] = 0x42
        dAtA[i] = 0x4a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeRuleId)))
        i += copy(dAtA[i:], m.TimeRuleId)
    }
    if len(m.SceneName) > 0 {
        dAtA[i] = 0x4a
        dAtA[i] = 0x52
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SceneName)))
        i += copy(dAtA[i:], m.SceneName)
    }
    if len(m.Desc) > 0 {
        dAtA[i] = 0x52
        dAtA[i] = 0x5a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Desc)))
        i += copy(dAtA[i:], m.Desc)
    }
    if m.Enable {
        dAtA[i] = 0x58
        dAtA[i] = 0x60
        i++
        if m.Enable {
            dAtA[i] = 1
@@ -4660,11 +4799,11 @@
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Cam.Size()))
        n1, err1 := m.Cam.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        n2, err2 := m.Cam.MarshalTo(dAtA[i:])
        if err2 != nil {
            return 0, err2
        }
        i += n1
        i += n2
    }
    if len(m.ServerId) > 0 {
        dAtA[i] = 0x1a
@@ -5034,14 +5173,38 @@
    return n
}

func (m *CameraRules) Size() (n int) {
func (m *CameraInfo) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.CameraId)
    l = len(m.RunServerName)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.Id)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.Name)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.RunType != 0 {
        n += 1 + sovProtomsg(uint64(m.RunType))
    }
    return n
}

func (m *CameraAndRules) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.CameraInfo != nil {
        l = m.CameraInfo.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if len(m.Rules) > 0 {
@@ -5059,7 +5222,13 @@
    }
    var l int
    _ = l
    l = len(m.GroupId)
    if len(m.CameraIds) > 0 {
        for _, s := range m.CameraIds {
            l = len(s)
            n += 1 + l + sovProtomsg(uint64(l))
        }
    }
    l = len(m.Id)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
@@ -7597,7 +7766,7 @@
    }
    return nil
}
func (m *CameraRules) Unmarshal(dAtA []byte) error {
func (m *CameraInfo) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
@@ -7620,15 +7789,15 @@
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: CameraRules: wiretype end group for non-group")
            return fmt.Errorf("proto: CameraInfo: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: CameraRules: illegal tag %d (wire type %d)", fieldNum, wire)
            return fmt.Errorf("proto: CameraInfo: 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)
                return fmt.Errorf("proto: wrong wireType = %d for field RunServerName", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
@@ -7656,7 +7825,179 @@
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.CameraId = string(dAtA[iNdEx:postIndex])
            m.RunServerName = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            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 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 != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field RunType", wireType)
            }
            m.RunType = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.RunType |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *CameraAndRules) 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: CameraAndRules: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: CameraAndRules: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CameraInfo", 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.CameraInfo == nil {
                m.CameraInfo = &CameraInfo{}
            }
            if err := m.CameraInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
@@ -7747,7 +8088,7 @@
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
                return fmt.Errorf("proto: wrong wireType = %d for field CameraIds", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
@@ -7775,9 +8116,41 @@
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.GroupId = string(dAtA[iNdEx:postIndex])
            m.CameraIds = append(m.CameraIds, string(dAtA[iNdEx:postIndex]))
            iNdEx = postIndex
        case 2:
            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 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field GroupText", wireType)
            }
@@ -7809,7 +8182,7 @@
            }
            m.GroupText = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
        case 4:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field AlarmLevel", wireType)
            }
@@ -7828,7 +8201,7 @@
                    break
                }
            }
        case 4:
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
            }
@@ -7862,7 +8235,7 @@
                return err
            }
            iNdEx = postIndex
        case 5:
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SetType", wireType)
            }
@@ -7894,7 +8267,7 @@
            }
            m.SetType = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 6:
        case 7:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field TemplateId", wireType)
            }
@@ -7926,7 +8299,7 @@
            }
            m.TemplateId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 7:
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field TemplateRule", wireType)
            }
@@ -7958,7 +8331,7 @@
            }
            m.TemplateRule = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 8:
        case 9:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field TimeRuleId", wireType)
            }
@@ -7990,7 +8363,7 @@
            }
            m.TimeRuleId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 9:
        case 10:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SceneName", wireType)
            }
@@ -8022,7 +8395,7 @@
            }
            m.SceneName = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 10:
        case 11:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
            }
@@ -8054,7 +8427,7 @@
            }
            m.Desc = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 11:
        case 12:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
            }

 protomsg.proto

@@ -92,24 +92,32 @@
    repeated Point points = 3;//点的集合
}

message CameraRules {
    string camera_id = 1;
message CameraInfo {
    string runServerName = 1;
    string id = 2;
    string name = 3;
    int32 run_type= 4;
}
message CameraAndRules {
    CameraInfo cameraInfo = 1;
    repeated GroupRule rules = 2;
}

message GroupRule {
    string group_id = 1;
    string group_text = 2;
    int32 alarm_level = 3;
    repeated Rule rules = 4;
    string set_type = 5;
    repeated string cameraIds = 1;
    string id = 2;

    string template_id = 6;
    string template_rule = 7;
    string time_rule_id = 8;
    string scene_name = 9;
    string desc = 10;
    bool enable = 11;
    string group_text = 3;
    int32 alarm_level = 4;
    repeated Rule rules = 5;
    string set_type = 6;

    string template_id = 7;
    string template_rule = 8;
    string time_rule_id = 9;
    string scene_name = 10;
    string desc = 11;
    bool enable = 12;
}

message Rule {