From cc4c955103dea54ed1181d0c0b91a88d5a0c491a Mon Sep 17 00:00:00 2001
From: 554325746@qq.com <554325746@qq.com>
Date: 星期二, 25 六月 2019 14:03:41 +0800
Subject: [PATCH] add es.proto

---
 sdk.pb.go      |  279 +
 sdk.proto      |    2 
 base.pb.go     |   45 
 es.proto       |   21 
 sysset.pb.go   | 1833 ++++++++++
 protomsg.pb.go | 7168 ++++++++++++++++++++++++++++++++++++++++-
 es.pb.go       |  888 +++++
 7 files changed, 9,898 insertions(+), 338 deletions(-)

diff --git a/base.pb.go b/base.pb.go
index 2034d85..610d731 100644
--- a/base.pb.go
+++ b/base.pb.go
@@ -5,7 +5,7 @@
 
 import (
 	fmt "fmt"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 )
@@ -19,12 +19,15 @@
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 // struct for sdk
 type Point struct {
-	X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
-	Y int32 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
+	X                    int32    `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
+	Y                    int32    `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *Point) Reset()         { *m = Point{} }
@@ -75,10 +78,13 @@
 }
 
 type Rect struct {
-	Left   int32 `protobuf:"varint,1,opt,name=left,proto3" json:"left,omitempty"`
-	Top    int32 `protobuf:"varint,2,opt,name=top,proto3" json:"top,omitempty"`
-	Right  int32 `protobuf:"varint,3,opt,name=right,proto3" json:"right,omitempty"`
-	Bottom int32 `protobuf:"varint,4,opt,name=bottom,proto3" json:"bottom,omitempty"`
+	Left                 int32    `protobuf:"varint,1,opt,name=left,proto3" json:"left,omitempty"`
+	Top                  int32    `protobuf:"varint,2,opt,name=top,proto3" json:"top,omitempty"`
+	Right                int32    `protobuf:"varint,3,opt,name=right,proto3" json:"right,omitempty"`
+	Bottom               int32    `protobuf:"varint,4,opt,name=bottom,proto3" json:"bottom,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *Rect) Reset()         { *m = Rect{} }
@@ -150,7 +156,7 @@
 func init() { proto.RegisterFile("base.proto", fileDescriptor_db1b6b0986796150) }
 
 var fileDescriptor_db1b6b0986796150 = []byte{
-	// 167 bytes of a gzipped FileDescriptorProto
+	// 158 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0x4a, 0x2c, 0x4e,
 	0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x00, 0x53, 0xb9, 0xc5, 0xe9, 0x4a, 0xca, 0x5c,
 	0xac, 0x01, 0xf9, 0x99, 0x79, 0x25, 0x42, 0x3c, 0x5c, 0x8c, 0x15, 0x12, 0x8c, 0x0a, 0x8c, 0x1a,
@@ -158,10 +164,9 @@
 	0x94, 0x9a, 0x5c, 0x22, 0x24, 0xc4, 0xc5, 0x92, 0x93, 0x9a, 0x56, 0x02, 0x55, 0x06, 0x66, 0x0b,
 	0x09, 0x70, 0x31, 0x97, 0xe4, 0x17, 0x40, 0xd5, 0x82, 0x98, 0x42, 0x22, 0x5c, 0xac, 0x45, 0x99,
 	0xe9, 0x19, 0x25, 0x12, 0xcc, 0x60, 0x31, 0x08, 0x47, 0x48, 0x8c, 0x8b, 0x2d, 0x29, 0xbf, 0xa4,
-	0x24, 0x3f, 0x57, 0x82, 0x05, 0x2c, 0x0c, 0xe5, 0x39, 0x49, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1,
-	0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70,
-	0xe3, 0xb1, 0x1c, 0x43, 0x12, 0x1b, 0xd8, 0x91, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa5,
-	0xe9, 0x4a, 0x5f, 0xb9, 0x00, 0x00, 0x00,
+	0x24, 0x3f, 0x57, 0x82, 0x05, 0x2c, 0x0c, 0xe5, 0x39, 0x09, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1,
+	0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x33, 0x1e, 0xcb, 0x31, 0x24, 0xb1, 0x81, 0x1d, 0x67,
+	0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xb3, 0xb0, 0xbd, 0x0b, 0xb1, 0x00, 0x00, 0x00,
 }
 
 func (m *Point) Marshal() (dAtA []byte, err error) {
@@ -188,6 +193,9 @@
 		dAtA[i] = 0x10
 		i++
 		i = encodeVarintBase(dAtA, i, uint64(m.Y))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -227,6 +235,9 @@
 		i++
 		i = encodeVarintBase(dAtA, i, uint64(m.Bottom))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -251,6 +262,9 @@
 	if m.Y != 0 {
 		n += 1 + sovBase(uint64(m.Y))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -271,6 +285,9 @@
 	}
 	if m.Bottom != 0 {
 		n += 1 + sovBase(uint64(m.Bottom))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
 	}
 	return n
 }
@@ -370,6 +387,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -499,6 +517,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
diff --git a/es.pb.go b/es.pb.go
new file mode 100644
index 0000000..caf4f07
--- /dev/null
+++ b/es.pb.go
@@ -0,0 +1,888 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: es.proto
+
+package protomsg
+
+import (
+	encoding_binary "encoding/binary"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	io "io"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Baseinfo struct {
+	FaceFeature          string   `protobuf:"bytes,1,opt,name=faceFeature,proto3" json:"faceFeature,omitempty"`
+	PersonId             string   `protobuf:"bytes,2,opt,name=personId,proto3" json:"personId,omitempty"`
+	TableId              string   `protobuf:"bytes,3,opt,name=tableId,proto3" json:"tableId,omitempty"`
+	TableName            string   `protobuf:"bytes,4,opt,name=tableName,proto3" json:"tableName,omitempty"`
+	CompareScore         float32  `protobuf:"fixed32,5,opt,name=compareScore,proto3" json:"compareScore,omitempty"`
+	PersonName           string   `protobuf:"bytes,6,opt,name=personName,proto3" json:"personName,omitempty"`
+	PersonPicUrl         string   `protobuf:"bytes,7,opt,name=personPicUrl,proto3" json:"personPicUrl,omitempty"`
+	PhoneNum             string   `protobuf:"bytes,8,opt,name=phoneNum,proto3" json:"phoneNum,omitempty"`
+	Sex                  string   `protobuf:"bytes,9,opt,name=sex,proto3" json:"sex,omitempty"`
+	Idcard               string   `protobuf:"bytes,10,opt,name=idcard,proto3" json:"idcard,omitempty"`
+	MonitorLevel         string   `protobuf:"bytes,11,opt,name=monitorLevel,proto3" json:"monitorLevel,omitempty"`
+	Content              string   `protobuf:"bytes,12,opt,name=content,proto3" json:"content,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Baseinfo) Reset()         { *m = Baseinfo{} }
+func (m *Baseinfo) String() string { return proto.CompactTextString(m) }
+func (*Baseinfo) ProtoMessage()    {}
+func (*Baseinfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_718db5c20d0f3738, []int{0}
+}
+func (m *Baseinfo) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *Baseinfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_Baseinfo.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 *Baseinfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Baseinfo.Merge(m, src)
+}
+func (m *Baseinfo) XXX_Size() int {
+	return m.Size()
+}
+func (m *Baseinfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_Baseinfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Baseinfo proto.InternalMessageInfo
+
+func (m *Baseinfo) GetFaceFeature() string {
+	if m != nil {
+		return m.FaceFeature
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetPersonId() string {
+	if m != nil {
+		return m.PersonId
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetTableId() string {
+	if m != nil {
+		return m.TableId
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetTableName() string {
+	if m != nil {
+		return m.TableName
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetCompareScore() float32 {
+	if m != nil {
+		return m.CompareScore
+	}
+	return 0
+}
+
+func (m *Baseinfo) GetPersonName() string {
+	if m != nil {
+		return m.PersonName
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetPersonPicUrl() string {
+	if m != nil {
+		return m.PersonPicUrl
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetPhoneNum() string {
+	if m != nil {
+		return m.PhoneNum
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetSex() string {
+	if m != nil {
+		return m.Sex
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetIdcard() string {
+	if m != nil {
+		return m.Idcard
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetMonitorLevel() string {
+	if m != nil {
+		return m.MonitorLevel
+	}
+	return ""
+}
+
+func (m *Baseinfo) GetContent() string {
+	if m != nil {
+		return m.Content
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*Baseinfo)(nil), "protomsg.Baseinfo")
+}
+
+func init() { proto.RegisterFile("es.proto", fileDescriptor_718db5c20d0f3738) }
+
+var fileDescriptor_718db5c20d0f3738 = []byte{
+	// 276 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x91, 0xc1, 0x4a, 0xf3, 0x40,
+	0x10, 0xc7, 0xbf, 0x4d, 0x3f, 0xd3, 0x64, 0xda, 0x43, 0xd9, 0x83, 0x0c, 0x22, 0x21, 0xf4, 0xd4,
+	0x93, 0x17, 0xdf, 0xa0, 0x07, 0xa1, 0x20, 0x45, 0x2a, 0x3e, 0xc0, 0x76, 0x33, 0xd5, 0x40, 0xb2,
+	0x1b, 0x76, 0xb7, 0xe2, 0xa3, 0xf8, 0x48, 0x1e, 0x7d, 0x04, 0x89, 0x57, 0x1f, 0x42, 0x32, 0x89,
+	0x9a, 0x9e, 0x32, 0xbf, 0xdf, 0x84, 0xf9, 0x0f, 0xb3, 0x90, 0x90, 0xbf, 0x6a, 0x9c, 0x0d, 0x56,
+	0x26, 0xfc, 0xa9, 0xfd, 0xe3, 0xf2, 0x2b, 0x82, 0x64, 0xad, 0x3c, 0x95, 0xe6, 0x60, 0x65, 0x0e,
+	0xb3, 0x83, 0xd2, 0x74, 0x43, 0x2a, 0x1c, 0x1d, 0xa1, 0xc8, 0xc5, 0x2a, 0xdd, 0x8d, 0x95, 0xbc,
+	0x80, 0xa4, 0x21, 0xe7, 0xad, 0xd9, 0x14, 0x18, 0x71, 0xfb, 0x97, 0x25, 0xc2, 0x34, 0xa8, 0x7d,
+	0x45, 0x9b, 0x02, 0x27, 0xdc, 0xfa, 0x41, 0x79, 0x09, 0x29, 0x97, 0x5b, 0x55, 0x13, 0xfe, 0xe7,
+	0xde, 0x9f, 0x90, 0x4b, 0x98, 0x6b, 0x5b, 0x37, 0xca, 0xd1, 0xbd, 0xb6, 0x8e, 0xf0, 0x2c, 0x17,
+	0xab, 0x68, 0x77, 0xe2, 0x64, 0x06, 0xd0, 0xe7, 0xf0, 0x88, 0x98, 0x47, 0x8c, 0x4c, 0x37, 0xa3,
+	0xa7, 0xbb, 0x52, 0x3f, 0xb8, 0x0a, 0xa7, 0xfc, 0xc7, 0x89, 0xe3, 0xdd, 0x9f, 0xac, 0xa1, 0xed,
+	0xb1, 0xc6, 0x64, 0xd8, 0x7d, 0x60, 0xb9, 0x80, 0x89, 0xa7, 0x17, 0x4c, 0x59, 0x77, 0xa5, 0x3c,
+	0x87, 0xb8, 0x2c, 0xb4, 0x72, 0x05, 0x02, 0xcb, 0x81, 0xba, 0xa4, 0xda, 0x9a, 0x32, 0x58, 0x77,
+	0x4b, 0xcf, 0x54, 0xe1, 0xac, 0x4f, 0x1a, 0xbb, 0xee, 0x12, 0xda, 0x9a, 0x40, 0x26, 0xe0, 0xbc,
+	0xbf, 0xc4, 0x80, 0xeb, 0xc5, 0x5b, 0x9b, 0x89, 0xf7, 0x36, 0x13, 0x1f, 0x6d, 0x26, 0x5e, 0x3f,
+	0xb3, 0x7f, 0xfb, 0x98, 0x9f, 0xe2, 0xfa, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x67, 0xdb, 0x72,
+	0x9d, 0x01, 0x00, 0x00,
+}
+
+func (m *Baseinfo) 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 *Baseinfo) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.FaceFeature) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.FaceFeature)))
+		i += copy(dAtA[i:], m.FaceFeature)
+	}
+	if len(m.PersonId) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.PersonId)))
+		i += copy(dAtA[i:], m.PersonId)
+	}
+	if len(m.TableId) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.TableId)))
+		i += copy(dAtA[i:], m.TableId)
+	}
+	if len(m.TableName) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.TableName)))
+		i += copy(dAtA[i:], m.TableName)
+	}
+	if m.CompareScore != 0 {
+		dAtA[i] = 0x2d
+		i++
+		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CompareScore))))
+		i += 4
+	}
+	if len(m.PersonName) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.PersonName)))
+		i += copy(dAtA[i:], m.PersonName)
+	}
+	if len(m.PersonPicUrl) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.PersonPicUrl)))
+		i += copy(dAtA[i:], m.PersonPicUrl)
+	}
+	if len(m.PhoneNum) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.PhoneNum)))
+		i += copy(dAtA[i:], m.PhoneNum)
+	}
+	if len(m.Sex) > 0 {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.Sex)))
+		i += copy(dAtA[i:], m.Sex)
+	}
+	if len(m.Idcard) > 0 {
+		dAtA[i] = 0x52
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.Idcard)))
+		i += copy(dAtA[i:], m.Idcard)
+	}
+	if len(m.MonitorLevel) > 0 {
+		dAtA[i] = 0x5a
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.MonitorLevel)))
+		i += copy(dAtA[i:], m.MonitorLevel)
+	}
+	if len(m.Content) > 0 {
+		dAtA[i] = 0x62
+		i++
+		i = encodeVarintEs(dAtA, i, uint64(len(m.Content)))
+		i += copy(dAtA[i:], m.Content)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func encodeVarintEs(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *Baseinfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.FaceFeature)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.PersonId)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.TableId)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.TableName)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	if m.CompareScore != 0 {
+		n += 5
+	}
+	l = len(m.PersonName)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.PersonPicUrl)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.PhoneNum)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.Sex)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.Idcard)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.MonitorLevel)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	l = len(m.Content)
+	if l > 0 {
+		n += 1 + l + sovEs(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func sovEs(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozEs(x uint64) (n int) {
+	return sovEs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Baseinfo) 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 ErrIntOverflowEs
+			}
+			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: Baseinfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Baseinfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FaceFeature", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FaceFeature = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PersonId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PersonId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TableId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TableId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TableName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompareScore", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.CompareScore = float32(math.Float32frombits(v))
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PersonName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PersonName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PersonPicUrl", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PersonPicUrl = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PhoneNum", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PhoneNum = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sex", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Sex = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 10:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Idcard", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Idcard = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MonitorLevel", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.MonitorLevel = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 12:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEs
+				}
+				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 ErrInvalidLengthEs
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Content = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipEs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthEs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthEs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipEs(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowEs
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowEs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowEs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthEs
+			}
+			iNdEx += length
+			if iNdEx < 0 {
+				return 0, ErrInvalidLengthEs
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowEs
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipEs(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+				if iNdEx < 0 {
+					return 0, ErrInvalidLengthEs
+				}
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthEs = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowEs   = fmt.Errorf("proto: integer overflow")
+)
diff --git a/es.proto b/es.proto
new file mode 100644
index 0000000..71d0db8
--- /dev/null
+++ b/es.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package protomsg;
+
+message Baseinfo{
+    string faceFeature = 1;
+    string personId    = 2;
+    string tableId     = 3;
+    string tableName   =4;
+    float  compareScore= 5;
+    string personName =6;
+    string personPicUrl =7;
+    string phoneNum =8;
+    string sex =9;
+    string idcard = 10;
+   string monitorLevel  = 11;
+    string content = 12;
+}
+
+
+
diff --git a/protomsg.pb.go b/protomsg.pb.go
index 2bd99c7..92ddadb 100644
--- a/protomsg.pb.go
+++ b/protomsg.pb.go
@@ -1,11 +1,13 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: protomsg.proto
 
 package protomsg
 
 import (
+	encoding_binary "encoding/binary"
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
+	io "io"
 	math "math"
 )
 
@@ -18,7 +20,7 @@
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 //TableChanged enum
 type TableChanged int32
@@ -105,18 +107,26 @@
 func (*SdkmsgWithTask) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{0}
 }
-
 func (m *SdkmsgWithTask) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SdkmsgWithTask.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *SdkmsgWithTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_SdkmsgWithTask.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 *SdkmsgWithTask) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SdkmsgWithTask.Merge(m, src)
 }
 func (m *SdkmsgWithTask) XXX_Size() int {
-	return xxx_messageInfo_SdkmsgWithTask.Size(m)
+	return m.Size()
 }
 func (m *SdkmsgWithTask) XXX_DiscardUnknown() {
 	xxx_messageInfo_SdkmsgWithTask.DiscardUnknown(m)
@@ -168,18 +178,26 @@
 func (*TaskLabel) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{1}
 }
-
 func (m *TaskLabel) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TaskLabel.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *TaskLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_TaskLabel.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 *TaskLabel) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TaskLabel.Merge(m, src)
 }
 func (m *TaskLabel) XXX_Size() int {
-	return xxx_messageInfo_TaskLabel.Size(m)
+	return m.Size()
 }
 func (m *TaskLabel) XXX_DiscardUnknown() {
 	xxx_messageInfo_TaskLabel.DiscardUnknown(m)
@@ -232,18 +250,26 @@
 func (*SdkMessage) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{2}
 }
-
 func (m *SdkMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SdkMessage.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *SdkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_SdkMessage.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 *SdkMessage) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SdkMessage.Merge(m, src)
 }
 func (m *SdkMessage) XXX_Size() int {
-	return xxx_messageInfo_SdkMessage.Size(m)
+	return m.Size()
 }
 func (m *SdkMessage) XXX_DiscardUnknown() {
 	xxx_messageInfo_SdkMessage.DiscardUnknown(m)
@@ -295,18 +321,26 @@
 func (*Area) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{3}
 }
-
 func (m *Area) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Area.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Area) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Area.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Area.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 *Area) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Area.Merge(m, src)
 }
 func (m *Area) XXX_Size() int {
-	return xxx_messageInfo_Area.Size(m)
+	return m.Size()
 }
 func (m *Area) XXX_DiscardUnknown() {
 	xxx_messageInfo_Area.DiscardUnknown(m)
@@ -366,18 +400,26 @@
 func (*Camera) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{4}
 }
-
 func (m *Camera) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Camera.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Camera) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Camera.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Camera.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 *Camera) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Camera.Merge(m, src)
 }
 func (m *Camera) XXX_Size() int {
-	return xxx_messageInfo_Camera.Size(m)
+	return m.Size()
 }
 func (m *Camera) XXX_DiscardUnknown() {
 	xxx_messageInfo_Camera.DiscardUnknown(m)
@@ -526,18 +568,26 @@
 func (*CameraAndTaskInfo) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{5}
 }
-
 func (m *CameraAndTaskInfo) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CameraAndTaskInfo.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *CameraAndTaskInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CameraAndTaskInfo.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_CameraAndTaskInfo.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 *CameraAndTaskInfo) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CameraAndTaskInfo.Merge(m, src)
 }
 func (m *CameraAndTaskInfo) XXX_Size() int {
-	return xxx_messageInfo_CameraAndTaskInfo.Size(m)
+	return m.Size()
 }
 func (m *CameraAndTaskInfo) XXX_DiscardUnknown() {
 	xxx_messageInfo_CameraAndTaskInfo.DiscardUnknown(m)
@@ -580,18 +630,26 @@
 func (*Task) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{6}
 }
-
 func (m *Task) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Task.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Task) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Task.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Task.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 *Task) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Task.Merge(m, src)
 }
 func (m *Task) XXX_Size() int {
-	return xxx_messageInfo_Task.Size(m)
+	return m.Size()
 }
 func (m *Task) XXX_DiscardUnknown() {
 	xxx_messageInfo_Task.DiscardUnknown(m)
@@ -669,18 +727,26 @@
 func (*TaskSdkInfo) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{7}
 }
-
 func (m *TaskSdkInfo) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TaskSdkInfo.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *TaskSdkInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TaskSdkInfo.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_TaskSdkInfo.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 *TaskSdkInfo) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TaskSdkInfo.Merge(m, src)
 }
 func (m *TaskSdkInfo) XXX_Size() int {
-	return xxx_messageInfo_TaskSdkInfo.Size(m)
+	return m.Size()
 }
 func (m *TaskSdkInfo) XXX_DiscardUnknown() {
 	xxx_messageInfo_TaskSdkInfo.DiscardUnknown(m)
@@ -727,18 +793,26 @@
 func (*CameraTask) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{8}
 }
-
 func (m *CameraTask) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CameraTask.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *CameraTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CameraTask.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_CameraTask.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 *CameraTask) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CameraTask.Merge(m, src)
 }
 func (m *CameraTask) XXX_Size() int {
-	return xxx_messageInfo_CameraTask.Size(m)
+	return m.Size()
 }
 func (m *CameraTask) XXX_DiscardUnknown() {
 	xxx_messageInfo_CameraTask.DiscardUnknown(m)
@@ -846,18 +920,26 @@
 func (*CameraTimerule) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{9}
 }
-
 func (m *CameraTimerule) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CameraTimerule.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *CameraTimerule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CameraTimerule.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_CameraTimerule.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 *CameraTimerule) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CameraTimerule.Merge(m, src)
 }
 func (m *CameraTimerule) XXX_Size() int {
-	return xxx_messageInfo_CameraTimerule.Size(m)
+	return m.Size()
 }
 func (m *CameraTimerule) XXX_DiscardUnknown() {
 	xxx_messageInfo_CameraTimerule.DiscardUnknown(m)
@@ -901,18 +983,26 @@
 func (*DayCtl) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{10}
 }
-
 func (m *DayCtl) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DayCtl.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *DayCtl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DayCtl.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_DayCtl.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 *DayCtl) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DayCtl.Merge(m, src)
 }
 func (m *DayCtl) XXX_Size() int {
-	return xxx_messageInfo_DayCtl.Size(m)
+	return m.Size()
 }
 func (m *DayCtl) XXX_DiscardUnknown() {
 	xxx_messageInfo_DayCtl.DiscardUnknown(m)
@@ -949,18 +1039,26 @@
 func (*TimeRange) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{11}
 }
-
 func (m *TimeRange) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TimeRange.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *TimeRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TimeRange.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_TimeRange.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 *TimeRange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TimeRange.Merge(m, src)
 }
 func (m *TimeRange) XXX_Size() int {
-	return xxx_messageInfo_TimeRange.Size(m)
+	return m.Size()
 }
 func (m *TimeRange) XXX_DiscardUnknown() {
 	xxx_messageInfo_TimeRange.DiscardUnknown(m)
@@ -998,18 +1096,26 @@
 func (*Polygon) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{12}
 }
-
 func (m *Polygon) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Polygon.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Polygon) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Polygon.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Polygon.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 *Polygon) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Polygon.Merge(m, src)
 }
 func (m *Polygon) XXX_Size() int {
-	return xxx_messageInfo_Polygon.Size(m)
+	return m.Size()
 }
 func (m *Polygon) XXX_DiscardUnknown() {
 	xxx_messageInfo_Polygon.DiscardUnknown(m)
@@ -1052,18 +1158,26 @@
 func (*CameraTaskArgs) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{13}
 }
-
 func (m *CameraTaskArgs) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CameraTaskArgs.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *CameraTaskArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CameraTaskArgs.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_CameraTaskArgs.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 *CameraTaskArgs) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CameraTaskArgs.Merge(m, src)
 }
 func (m *CameraTaskArgs) XXX_Size() int {
-	return xxx_messageInfo_CameraTaskArgs.Size(m)
+	return m.Size()
 }
 func (m *CameraTaskArgs) XXX_DiscardUnknown() {
 	xxx_messageInfo_CameraTaskArgs.DiscardUnknown(m)
@@ -1099,18 +1213,26 @@
 func (*TaskGroupArgs) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{14}
 }
-
 func (m *TaskGroupArgs) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TaskGroupArgs.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *TaskGroupArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TaskGroupArgs.Marshal(b, m, deterministic)
+	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 xxx_messageInfo_TaskGroupArgs.Size(m)
+	return m.Size()
 }
 func (m *TaskGroupArgs) XXX_DiscardUnknown() {
 	xxx_messageInfo_TaskGroupArgs.DiscardUnknown(m)
@@ -1148,18 +1270,26 @@
 func (*GroupRule) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{15}
 }
-
 func (m *GroupRule) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GroupRule.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GroupRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GroupRule.Marshal(b, m, deterministic)
+	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 xxx_messageInfo_GroupRule.Size(m)
+	return m.Size()
 }
 func (m *GroupRule) XXX_DiscardUnknown() {
 	xxx_messageInfo_GroupRule.DiscardUnknown(m)
@@ -1219,18 +1349,26 @@
 func (*Rule) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{16}
 }
-
 func (m *Rule) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Rule.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Rule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Rule.Marshal(b, m, deterministic)
+	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 xxx_messageInfo_Rule.Size(m)
+	return m.Size()
 }
 func (m *Rule) XXX_DiscardUnknown() {
 	xxx_messageInfo_Rule.DiscardUnknown(m)
@@ -1346,18 +1484,26 @@
 func (*Sdk) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{17}
 }
-
 func (m *Sdk) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Sdk.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Sdk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Sdk.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Sdk.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 *Sdk) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Sdk.Merge(m, src)
 }
 func (m *Sdk) XXX_Size() int {
-	return xxx_messageInfo_Sdk.Size(m)
+	return m.Size()
 }
 func (m *Sdk) XXX_DiscardUnknown() {
 	xxx_messageInfo_Sdk.DiscardUnknown(m)
@@ -1462,18 +1608,26 @@
 func (*SdkArg) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{18}
 }
-
 func (m *SdkArg) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_SdkArg.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *SdkArg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_SdkArg.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_SdkArg.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 *SdkArg) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SdkArg.Merge(m, src)
 }
 func (m *SdkArg) XXX_Size() int {
-	return xxx_messageInfo_SdkArg.Size(m)
+	return m.Size()
 }
 func (m *SdkArg) XXX_DiscardUnknown() {
 	xxx_messageInfo_SdkArg.DiscardUnknown(m)
@@ -1547,18 +1701,26 @@
 func (*DbChangeMessage) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{19}
 }
-
 func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_DbChangeMessage.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *DbChangeMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_DbChangeMessage.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_DbChangeMessage.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 *DbChangeMessage) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DbChangeMessage.Merge(m, src)
 }
 func (m *DbChangeMessage) XXX_Size() int {
-	return xxx_messageInfo_DbChangeMessage.Size(m)
+	return m.Size()
 }
 func (m *DbChangeMessage) XXX_DiscardUnknown() {
 	xxx_messageInfo_DbChangeMessage.DiscardUnknown(m)
@@ -1614,18 +1776,26 @@
 func (*CameraPolygon) Descriptor() ([]byte, []int) {
 	return fileDescriptor_32de24555f916688, []int{20}
 }
-
 func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_CameraPolygon.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *CameraPolygon) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_CameraPolygon.Marshal(b, m, deterministic)
+	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 xxx_messageInfo_CameraPolygon.Size(m)
+	return m.Size()
 }
 func (m *CameraPolygon) XXX_DiscardUnknown() {
 	xxx_messageInfo_CameraPolygon.DiscardUnknown(m)
@@ -1718,104 +1888,6730 @@
 func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }
 
 var fileDescriptor_32de24555f916688 = []byte{
-	// 1573 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x8e, 0x14, 0x47,
-	0x12, 0xa6, 0xff, 0xbb, 0xa2, 0x7f, 0x68, 0x72, 0x59, 0x28, 0x60, 0xd1, 0x0e, 0x05, 0xab, 0x1d,
-	0xa1, 0x85, 0xc3, 0xc0, 0x0b, 0xf4, 0x32, 0xcb, 0xaa, 0x25, 0x8c, 0x70, 0xf5, 0x18, 0xdf, 0x5c,
-	0xca, 0xee, 0xcc, 0x29, 0x4a, 0x5d, 0x9d, 0xd5, 0xca, 0xcc, 0x1a, 0x98, 0x83, 0x9f, 0xc0, 0x96,
-	0x7c, 0xf5, 0x2b, 0xf8, 0x41, 0xfc, 0x1c, 0xbe, 0xf9, 0x62, 0xf9, 0x1d, 0xac, 0x88, 0xcc, 0xaa,
-	0xfe, 0x61, 0x6c, 0x23, 0xdf, 0x22, 0xbe, 0x88, 0xce, 0x8c, 0xf8, 0x22, 0x32, 0xa2, 0x1a, 0xc6,
-	0x1b, 0x5d, 0xd8, 0x62, 0x6d, 0xd2, 0xa7, 0x24, 0xb0, 0x7e, 0xa5, 0xdf, 0x85, 0x05, 0x37, 0xd2,
-	0xa1, 0x91, 0x85, 0xf1, 0x5c, 0xac, 0xd6, 0x26, 0xfd, 0x32, 0xb3, 0xef, 0xce, 0xb8, 0x59, 0xb1,
-	0x9b, 0xd0, 0x31, 0x62, 0x95, 0x89, 0xb0, 0x71, 0xd4, 0x38, 0x0e, 0x62, 0xa7, 0xb0, 0x10, 0x7a,
-	0x46, 0xac, 0xec, 0xe5, 0x46, 0x86, 0x4d, 0xc2, 0x2b, 0xd5, 0x5b, 0x5e, 0xf3, 0xb5, 0x0c, 0x5b,
-	0xb5, 0x05, 0x55, 0x6f, 0x11, 0xdc, 0xf2, 0xb0, 0x7d, 0xd4, 0x38, 0x1e, 0xc6, 0x95, 0x1a, 0x7d,
-	0xd3, 0x80, 0x00, 0x2f, 0x7b, 0xc5, 0x17, 0x32, 0x67, 0xb7, 0xa0, 0x6b, 0xb9, 0xd9, 0x5e, 0xe9,
-	0x35, 0x76, 0x17, 0xfa, 0x28, 0x29, 0x3c, 0xda, 0x5d, 0x5a, 0xeb, 0xec, 0x39, 0xf4, 0x31, 0x30,
-	0x75, 0x5e, 0x98, 0xb0, 0x75, 0xd4, 0x3a, 0x1e, 0x9c, 0x84, 0x4f, 0xeb, 0x84, 0xf7, 0x33, 0x8a,
-	0x6b, 0x4f, 0xcc, 0x2d, 0x53, 0x42, 0x7e, 0xa0, 0x78, 0x3a, 0xb1, 0x53, 0xa2, 0xf7, 0x00, 0x73,
-	0xb1, 0xfa, 0x4c, 0x1a, 0xc3, 0x53, 0xc9, 0x26, 0xd0, 0x5a, 0xd6, 0xa1, 0xa0, 0x88, 0xbf, 0x5a,
-	0x72, 0x21, 0xb4, 0x0f, 0xc2, 0x29, 0xec, 0x09, 0xf4, 0x30, 0x9a, 0x9c, 0x2f, 0x28, 0xef, 0xc1,
-	0xc9, 0xdf, 0xb6, 0x01, 0xd4, 0xb9, 0xc5, 0x95, 0x0f, 0x63, 0xd0, 0xde, 0x61, 0x82, 0xe4, 0xe8,
-	0x25, 0xb4, 0xa7, 0x5a, 0x72, 0x36, 0x86, 0xa6, 0xbf, 0xb1, 0x13, 0x37, 0x5d, 0xe2, 0x1b, 0xae,
-	0xa5, 0xb2, 0x99, 0xa0, 0x3b, 0x3b, 0x71, 0xad, 0xe3, 0x39, 0x6a, 0xcb, 0x35, 0xc9, 0xd1, 0x8f,
-	0x2d, 0xe8, 0xbe, 0xe0, 0x6b, 0xa9, 0x77, 0x8f, 0x0a, 0xe8, 0xa8, 0xca, 0xbd, 0xb9, 0x75, 0x47,
-	0x8c, 0x0a, 0xd9, 0xa2, 0xa3, 0x49, 0x46, 0x8c, 0x52, 0x6c, 0x3b, 0x3f, 0xca, 0xf0, 0x16, 0x74,
-	0xb9, 0x96, 0x3c, 0x13, 0x61, 0x87, 0x3c, 0xbd, 0xc6, 0xfe, 0x01, 0x41, 0x5e, 0xa8, 0x34, 0xb3,
-	0xa5, 0x90, 0x61, 0xf7, 0xa8, 0x71, 0xdc, 0x8c, 0xb7, 0x00, 0x06, 0x9f, 0x73, 0xeb, 0x8c, 0x3d,
-	0x32, 0xd6, 0x3a, 0xde, 0xa2, 0xad, 0xd9, 0x84, 0x7d, 0x77, 0x0b, 0xca, 0x14, 0xf1, 0x26, 0x0c,
-	0x7c, 0xc4, 0x1b, 0xf4, 0xd9, 0x14, 0xda, 0x86, 0xe0, 0xa2, 0x43, 0x19, 0xcf, 0x2c, 0x8d, 0xd4,
-	0x94, 0xc9, 0xc0, 0x75, 0x42, 0xa5, 0x3b, 0xb2, 0x8c, 0x79, 0x5f, 0x68, 0x11, 0x0e, 0x9d, 0xad,
-	0xd2, 0xb1, 0x72, 0x0b, 0xcd, 0x95, 0x08, 0x47, 0xae, 0x72, 0xa4, 0xe0, 0x2f, 0xb4, 0x34, 0x52,
-	0x5f, 0x48, 0x11, 0x8e, 0xdd, 0x2f, 0x2a, 0x9d, 0xdd, 0x07, 0xc8, 0x4c, 0xa2, 0x4b, 0xa5, 0x32,
-	0x95, 0x86, 0xd7, 0x8f, 0x1a, 0xc7, 0xfd, 0x38, 0xc8, 0x4c, 0xec, 0x00, 0x34, 0xeb, 0x52, 0x25,
-	0x52, 0xf1, 0x45, 0x2e, 0xc3, 0x89, 0x33, 0xeb, 0x52, 0xfd, 0x8f, 0x00, 0x76, 0x07, 0xfa, 0x68,
-	0x26, 0x76, 0x6f, 0x50, 0xfc, 0x3d, 0x5d, 0xaa, 0x33, 0x24, 0x38, 0x82, 0x11, 0x9a, 0xe8, 0x1a,
-	0x9d, 0x64, 0x22, 0x64, 0x74, 0xf3, 0x40, 0x97, 0x6a, 0x4e, 0xd8, 0x4c, 0x44, 0x4b, 0xb8, 0xe1,
-	0xca, 0x38, 0x55, 0x02, 0x5b, 0x68, 0xa6, 0xce, 0x0b, 0x76, 0x0c, 0xdd, 0x25, 0x81, 0x54, 0xd5,
-	0xc1, 0xc9, 0x64, 0xdb, 0x66, 0xce, 0x39, 0xf6, 0x76, 0xf6, 0x08, 0x3a, 0xd8, 0x6d, 0x26, 0x6c,
-	0xd2, 0x83, 0x18, 0xef, 0xf7, 0x63, 0xec, 0x8c, 0xd1, 0x4f, 0x0d, 0x68, 0xd3, 0x43, 0xff, 0x2b,
-	0xcf, 0xee, 0x1e, 0x04, 0x4b, 0x2d, 0xb9, 0x95, 0x09, 0xb7, 0xbe, 0x05, 0xfb, 0x0e, 0x98, 0xda,
-	0x1d, 0xe3, 0xe2, 0xd2, 0x37, 0x92, 0x37, 0xfe, 0xf7, 0x12, 0x8d, 0xe5, 0x46, 0xf8, 0x5f, 0x76,
-	0x7c, 0x0d, 0x09, 0x98, 0x5a, 0x0c, 0xc5, 0x53, 0xda, 0x25, 0x4a, 0xbd, 0x86, 0x7c, 0x66, 0x26,
-	0xe1, 0x39, 0xd7, 0x6b, 0xea, 0xa5, 0x7e, 0xdc, 0xcb, 0xcc, 0x14, 0x55, 0x34, 0x09, 0x99, 0x27,
-	0xe7, 0x39, 0x4f, 0xa9, 0x9d, 0xfa, 0x71, 0x4f, 0xc8, 0xfc, 0x65, 0xce, 0xd3, 0xe8, 0x0c, 0x06,
-	0x98, 0xe0, 0x5c, 0x38, 0x02, 0x23, 0x68, 0x63, 0xfc, 0x9e, 0xbe, 0x43, 0x56, 0xc8, 0xc6, 0x1e,
-	0x40, 0xdb, 0x88, 0x9a, 0xb9, 0xd1, 0xde, 0x28, 0x89, 0xc9, 0x14, 0xfd, 0xdc, 0x04, 0x70, 0x84,
-	0x13, 0x7b, 0x87, 0x0f, 0x0d, 0x93, 0x27, 0x6b, 0xe2, 0x1f, 0x2d, 0x26, 0x4f, 0xc0, 0x4c, 0xb0,
-	0xdb, 0x6e, 0x56, 0xa0, 0xa9, 0xb5, 0xe5, 0x7a, 0x26, 0xd8, 0x13, 0x08, 0x6c, 0xb6, 0x96, 0x89,
-	0x2e, 0x73, 0x19, 0xb6, 0xe9, 0xf2, 0x9d, 0xfa, 0x9e, 0xf2, 0xcb, 0x17, 0x36, 0x8f, 0xfb, 0xe8,
-	0x12, 0x97, 0xb9, 0xa4, 0xf6, 0x93, 0x7c, 0x69, 0x9d, 0xbf, 0x63, 0x31, 0x20, 0x84, 0xcc, 0x0f,
-	0x60, 0xe8, 0xcc, 0x42, 0x5e, 0x64, 0x4b, 0x47, 0x26, 0xb6, 0x18, 0x62, 0xa7, 0x04, 0xed, 0xd1,
-	0xd6, 0xdb, 0xa3, 0x8d, 0xfd, 0x13, 0x06, 0xbe, 0x42, 0x3b, 0xa4, 0x82, 0x83, 0xc8, 0x61, 0x5b,
-	0xa5, 0x60, 0xaf, 0x4a, 0x0c, 0xda, 0x66, 0xe7, 0xc5, 0xa2, 0x8c, 0x19, 0x67, 0x26, 0x39, 0x2f,
-	0xf3, 0x9c, 0x1e, 0x6c, 0x3f, 0xee, 0x66, 0xe6, 0x65, 0x99, 0xe7, 0xec, 0x08, 0x86, 0x79, 0xa6,
-	0x56, 0x49, 0xc5, 0x87, 0x7b, 0xb2, 0x80, 0x18, 0xb5, 0xbc, 0x88, 0x3e, 0x87, 0xb1, 0xe7, 0x39,
-	0x5b, 0x4b, 0x4c, 0xf4, 0x93, 0x86, 0xda, 0xbd, 0x5d, 0x26, 0x7d, 0x67, 0x56, 0xbc, 0x45, 0xaf,
-	0xa1, 0xeb, 0xb8, 0xc4, 0xe9, 0x2e, 0xf8, 0xa5, 0x9f, 0xb5, 0x28, 0xb2, 0x13, 0x00, 0xf7, 0x43,
-	0xae, 0x52, 0xe9, 0x1b, 0x60, 0x77, 0x94, 0xe3, 0x19, 0x68, 0x8a, 0xe9, 0x7c, 0x12, 0xa3, 0x67,
-	0x10, 0xd4, 0x38, 0x2d, 0x4c, 0xcb, 0xb5, 0xad, 0x17, 0x26, 0x2a, 0x78, 0x91, 0x54, 0x55, 0x27,
-	0xa0, 0x18, 0xbd, 0x85, 0xde, 0x9b, 0x22, 0xbf, 0x4c, 0x0b, 0xf5, 0x49, 0x09, 0xfd, 0x1b, 0xba,
-	0x9b, 0x22, 0x53, 0xb6, 0xda, 0x6f, 0xd7, 0xb7, 0x31, 0xbd, 0x41, 0x3c, 0xf6, 0xe6, 0x68, 0x59,
-	0xf3, 0xc5, 0xcd, 0x6a, 0xaa, 0x53, 0xb3, 0xdf, 0x8b, 0x8d, 0x83, 0x5e, 0x7c, 0x0e, 0x01, 0x71,
-	0xcf, 0x75, 0x5a, 0xf5, 0xfb, 0xed, 0xfd, 0x37, 0xf1, 0x7f, 0x5d, 0x94, 0x1b, 0x3c, 0xc8, 0x3d,
-	0x7c, 0x94, 0xa2, 0xaf, 0x60, 0xb4, 0x67, 0xda, 0x6d, 0xe9, 0xc6, 0x5e, 0x4b, 0x3f, 0x87, 0x41,
-	0x8a, 0x5e, 0x54, 0x09, 0xf3, 0x31, 0xa1, 0x74, 0x04, 0x56, 0x25, 0x86, 0xb4, 0x12, 0x4d, 0xf4,
-	0x6d, 0x03, 0x82, 0xda, 0x82, 0x5d, 0xea, 0xce, 0xa8, 0x4f, 0xef, 0x91, 0x3e, 0xa3, 0x01, 0xed,
-	0x4c, 0x56, 0x7e, 0xb0, 0x9e, 0xb0, 0x80, 0x90, 0x33, 0xf9, 0xc1, 0x62, 0x13, 0xd3, 0xb8, 0x48,
-	0x72, 0x79, 0x21, 0x73, 0xbf, 0xe2, 0x80, 0xa0, 0x57, 0x88, 0xe0, 0x90, 0x74, 0x81, 0xb5, 0x0f,
-	0x87, 0x24, 0xc5, 0xe4, 0x8c, 0xd1, 0x2f, 0x4d, 0x68, 0xc7, 0x57, 0xb5, 0xde, 0x23, 0x18, 0x7b,
-	0x6a, 0xab, 0xec, 0x5d, 0x08, 0xc3, 0x65, 0x5d, 0x82, 0xd9, 0xc1, 0x30, 0x68, 0x1d, 0x14, 0xe0,
-	0x3e, 0xc0, 0xc6, 0xf5, 0x01, 0x5a, 0xdd, 0x9c, 0x0c, 0x3c, 0x32, 0x13, 0xec, 0xef, 0xd0, 0x35,
-	0x82, 0x4e, 0xee, 0xd4, 0x1f, 0x60, 0x33, 0x81, 0xfb, 0x03, 0x61, 0xae, 0xd3, 0x84, 0xe7, 0x19,
-	0x37, 0xd5, 0xe3, 0x36, 0x02, 0x0b, 0x34, 0x45, 0x08, 0x27, 0x77, 0xb1, 0x91, 0x9a, 0xdb, 0x42,
-	0xd3, 0xe3, 0x0e, 0xe2, 0x5a, 0x67, 0x0f, 0x61, 0x54, 0xc9, 0x6e, 0x3f, 0xb9, 0x1d, 0x3c, 0xac,
-	0xc0, 0x6a, 0x49, 0x55, 0x97, 0x5c, 0xf0, 0xbc, 0x94, 0x7e, 0x2d, 0xfb, 0x4b, 0xde, 0x22, 0x74,
-	0xe5, 0x6b, 0xa7, 0xe5, 0x96, 0xcb, 0xe4, 0x7d, 0x66, 0xdf, 0x25, 0x1b, 0x5d, 0x2d, 0xe9, 0x01,
-	0x82, 0xf8, 0x19, 0xf6, 0x46, 0xef, 0xd7, 0x74, 0xb8, 0x57, 0xd3, 0xe8, 0x87, 0x26, 0xb4, 0xe6,
-	0xe2, 0xe3, 0x99, 0x7a, 0x87, 0x3e, 0xf2, 0x92, 0x83, 0xaf, 0x4e, 0x8a, 0xd4, 0x9b, 0xd4, 0x15,
-	0x9f, 0x9d, 0x8f, 0xa0, 0x4d, 0xbd, 0xfd, 0xd1, 0x38, 0x9d, 0x53, 0x16, 0x31, 0x59, 0x31, 0x8d,
-	0x6c, 0x59, 0x28, 0x4f, 0x32, 0xc9, 0xf8, 0x66, 0x4b, 0x9d, 0x7b, 0x66, 0x51, 0xc4, 0x76, 0xf2,
-	0x2b, 0x0d, 0x1f, 0xbf, 0x27, 0x15, 0x1c, 0x84, 0x13, 0x60, 0x67, 0x68, 0x92, 0x83, 0x23, 0xd5,
-	0x0f, 0x4d, 0x72, 0xd8, 0x5b, 0x8a, 0xc1, 0xc1, 0x52, 0xdc, 0x4e, 0x54, 0x38, 0xdc, 0x7b, 0xf5,
-	0x94, 0x1e, 0xb8, 0xef, 0x88, 0x6a, 0xb9, 0x7d, 0xdf, 0x80, 0xae, 0x4b, 0x04, 0x07, 0x8f, 0x6b,
-	0x05, 0x3f, 0x78, 0x48, 0xf9, 0xd3, 0x2f, 0xbe, 0x60, 0xfb, 0xc5, 0xb7, 0x2e, 0x8d, 0xa5, 0x06,
-	0xec, 0xc7, 0x24, 0x23, 0x56, 0xaa, 0xac, 0xda, 0xcf, 0x24, 0xe3, 0x2d, 0x6e, 0x34, 0x3a, 0x5a,
-	0x9c, 0x52, 0x77, 0x41, 0x6f, 0xdb, 0x05, 0xd1, 0x77, 0x0d, 0xb8, 0x7e, 0xba, 0x78, 0xf1, 0x0e,
-	0x1d, 0xaa, 0xaf, 0xe9, 0xff, 0xe0, 0x37, 0x09, 0x26, 0x88, 0x31, 0x8e, 0x4f, 0x6e, 0xed, 0x4e,
-	0x9a, 0x45, 0x2e, 0x9d, 0xb3, 0x88, 0x9d, 0x93, 0x6f, 0x80, 0x66, 0xdd, 0x00, 0x8f, 0xa1, 0xcb,
-	0x97, 0x36, 0x2b, 0x14, 0x45, 0x3e, 0x3e, 0x61, 0x3b, 0xbb, 0x71, 0x31, 0x25, 0x4b, 0xec, 0x3d,
-	0xa8, 0xa0, 0xea, 0xbc, 0xa8, 0xbe, 0x60, 0x51, 0x8e, 0x7e, 0x6d, 0xc0, 0xc8, 0xcd, 0xc6, 0xdf,
-	0x9b, 0xbc, 0x7f, 0xb8, 0xb6, 0xaf, 0xf8, 0xd6, 0xc6, 0x3f, 0x35, 0xfe, 0xad, 0xfa, 0x9b, 0x2a,
-	0x15, 0xb7, 0xaf, 0xd5, 0x59, 0x9a, 0x4a, 0x9d, 0xe4, 0x99, 0xaa, 0xd6, 0xf3, 0xc0, 0x63, 0xaf,
-	0x32, 0x25, 0xd9, 0xbf, 0x60, 0x2c, 0x32, 0x2d, 0x29, 0x60, 0xe7, 0xe4, 0x48, 0x1d, 0xd5, 0x28,
-	0xb9, 0x55, 0xe5, 0xea, 0xed, 0x94, 0xeb, 0x21, 0x8c, 0x84, 0x3c, 0x97, 0x6a, 0x29, 0x13, 0x63,
-	0xb9, 0x75, 0xad, 0xd6, 0x89, 0x87, 0x1e, 0x9c, 0x23, 0xf6, 0xf8, 0x6b, 0x18, 0xee, 0xd2, 0xca,
-	0x86, 0xd0, 0x3f, 0x4b, 0x1c, 0x01, 0x93, 0x6b, 0x6c, 0x02, 0xc3, 0x4a, 0xc3, 0x39, 0x35, 0x69,
-	0xb0, 0x9b, 0x30, 0xd9, 0x45, 0x70, 0xb0, 0x4f, 0x9a, 0x0c, 0xa0, 0x7b, 0x96, 0x90, 0x47, 0x8b,
-	0x8d, 0x20, 0x70, 0xf2, 0x5c, 0xac, 0x26, 0x6d, 0x76, 0x03, 0x46, 0xb5, 0x8a, 0xf3, 0x71, 0xd2,
-	0x61, 0x01, 0x74, 0xce, 0x12, 0xb4, 0x76, 0x1f, 0x3f, 0x85, 0x7e, 0x55, 0x16, 0x3c, 0x64, 0xa6,
-	0x8c, 0xd4, 0x76, 0x72, 0x0d, 0xe5, 0x2f, 0xe8, 0x45, 0x4c, 0x1a, 0x28, 0x9f, 0xca, 0x5c, 0x5a,
-	0x39, 0x69, 0x2e, 0xba, 0x54, 0xcd, 0x67, 0xbf, 0x05, 0x00, 0x00, 0xff, 0xff, 0xe5, 0xa4, 0x6a,
-	0x9e, 0xab, 0x0e, 0x00, 0x00,
+	// 1599 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x8e, 0x14, 0xc9,
+	0x11, 0xa6, 0xfa, 0xbf, 0xa2, 0x7f, 0x68, 0xd2, 0x18, 0x0a, 0x30, 0xe3, 0xa1, 0xc0, 0xf2, 0x08,
+	0x19, 0x0e, 0x03, 0x2f, 0xd0, 0x30, 0xc6, 0x6a, 0x09, 0x23, 0x5c, 0x3d, 0xc6, 0x37, 0x97, 0xb2,
+	0x3b, 0x73, 0x8a, 0x52, 0x57, 0x57, 0xb5, 0x32, 0xb3, 0x06, 0xe6, 0xe0, 0x27, 0xb0, 0x25, 0x5f,
+	0x79, 0x85, 0x7d, 0x90, 0x95, 0xf6, 0xb8, 0x6f, 0xb0, 0x2b, 0x56, 0xda, 0xcb, 0x6a, 0xdf, 0x61,
+	0x15, 0x91, 0x59, 0xd5, 0x3f, 0xcc, 0xee, 0xa2, 0xbd, 0x45, 0x7c, 0x11, 0x9d, 0x19, 0xf1, 0x45,
+	0x64, 0x44, 0x35, 0x8c, 0xd6, 0xaa, 0x30, 0xc5, 0x4a, 0x27, 0x8f, 0x49, 0x60, 0xbd, 0x4a, 0xbf,
+	0x0d, 0x73, 0xae, 0xa5, 0x45, 0x43, 0x03, 0xa3, 0x99, 0x58, 0xae, 0x74, 0xf2, 0xaf, 0xd4, 0xbc,
+	0x3d, 0xe5, 0x7a, 0xc9, 0xae, 0x43, 0x5b, 0x8b, 0x65, 0x2a, 0x02, 0xef, 0xd0, 0x3b, 0xf2, 0x23,
+	0xab, 0xb0, 0x00, 0xba, 0x5a, 0x2c, 0xcd, 0xc5, 0x5a, 0x06, 0x0d, 0xc2, 0x2b, 0xd5, 0x59, 0x5e,
+	0xf1, 0x95, 0x0c, 0x9a, 0xb5, 0x05, 0x55, 0x67, 0x11, 0xdc, 0xf0, 0xa0, 0x75, 0xe8, 0x1d, 0x0d,
+	0xa2, 0x4a, 0x0d, 0xff, 0xeb, 0x81, 0x8f, 0x97, 0xbd, 0xe4, 0x73, 0x99, 0xb1, 0x1b, 0xd0, 0x31,
+	0x5c, 0x6f, 0xae, 0x74, 0x1a, 0xbb, 0x0d, 0x3d, 0x94, 0x72, 0x3c, 0xda, 0x5e, 0x5a, 0xeb, 0xec,
+	0x29, 0xf4, 0x30, 0xb0, 0xfc, 0xac, 0xd0, 0x41, 0xf3, 0xb0, 0x79, 0xd4, 0x3f, 0x0e, 0x1e, 0xd7,
+	0x09, 0xef, 0x66, 0x14, 0xd5, 0x9e, 0x98, 0x5b, 0x9a, 0x0b, 0xf9, 0x9e, 0xe2, 0x69, 0x47, 0x56,
+	0x09, 0xdf, 0x01, 0xcc, 0xc4, 0xf2, 0xef, 0x52, 0x6b, 0x9e, 0x48, 0x36, 0x86, 0xe6, 0xa2, 0x0e,
+	0x05, 0x45, 0xfc, 0xd5, 0x82, 0x0b, 0xa1, 0x5c, 0x10, 0x56, 0x61, 0x8f, 0xa0, 0x8b, 0xd1, 0x64,
+	0x7c, 0x4e, 0x79, 0xf7, 0x8f, 0x7f, 0xb7, 0x09, 0xa0, 0xce, 0x2d, 0xaa, 0x7c, 0x18, 0x83, 0xd6,
+	0x16, 0x13, 0x24, 0x87, 0x2f, 0xa0, 0x35, 0x51, 0x92, 0xb3, 0x11, 0x34, 0xdc, 0x8d, 0xed, 0xa8,
+	0x61, 0x13, 0x5f, 0x73, 0x25, 0x73, 0x93, 0x0a, 0xba, 0xb3, 0x1d, 0xd5, 0x3a, 0x9e, 0x93, 0x6f,
+	0xb8, 0x26, 0x39, 0xfc, 0xb2, 0x09, 0x9d, 0xe7, 0x7c, 0x25, 0xd5, 0xf6, 0x51, 0x3e, 0x1d, 0x55,
+	0xb9, 0x37, 0x36, 0xee, 0x88, 0x51, 0x21, 0x9b, 0x74, 0x34, 0xc9, 0x88, 0x51, 0x8a, 0x2d, 0xeb,
+	0x47, 0x19, 0xde, 0x80, 0x0e, 0x57, 0x92, 0xa7, 0x22, 0x68, 0x93, 0xa7, 0xd3, 0xd8, 0x1f, 0xc0,
+	0xcf, 0x8a, 0x3c, 0x49, 0x4d, 0x29, 0x64, 0xd0, 0x39, 0xf4, 0x8e, 0x1a, 0xd1, 0x06, 0xc0, 0xe0,
+	0x33, 0x6e, 0xac, 0xb1, 0x4b, 0xc6, 0x5a, 0xc7, 0x5b, 0x94, 0xd1, 0xeb, 0xa0, 0x67, 0x6f, 0x41,
+	0x99, 0x22, 0x5e, 0x07, 0xbe, 0x8b, 0x78, 0x8d, 0x3e, 0xeb, 0x42, 0x99, 0x00, 0x6c, 0x74, 0x28,
+	0xe3, 0x99, 0xa5, 0x96, 0x8a, 0x32, 0xe9, 0xdb, 0x4e, 0xa8, 0x74, 0x4b, 0x96, 0xd6, 0xef, 0x0a,
+	0x25, 0x82, 0x81, 0xb5, 0x55, 0x3a, 0x56, 0x6e, 0xae, 0x78, 0x2e, 0x82, 0xa1, 0xad, 0x1c, 0x29,
+	0xf8, 0x0b, 0x25, 0xb5, 0x54, 0xe7, 0x52, 0x04, 0x23, 0xfb, 0x8b, 0x4a, 0x67, 0x77, 0x01, 0x52,
+	0x1d, 0xab, 0x32, 0xcf, 0xd3, 0x3c, 0x09, 0xae, 0x1e, 0x7a, 0x47, 0xbd, 0xc8, 0x4f, 0x75, 0x64,
+	0x01, 0x34, 0xab, 0x32, 0x8f, 0x65, 0xce, 0xe7, 0x99, 0x0c, 0xc6, 0xd6, 0xac, 0xca, 0xfc, 0xaf,
+	0x04, 0xb0, 0x5b, 0xd0, 0x43, 0x33, 0xb1, 0x7b, 0x8d, 0xe2, 0xef, 0xaa, 0x32, 0x3f, 0x45, 0x82,
+	0x43, 0x18, 0xa2, 0x89, 0xae, 0x51, 0x71, 0x2a, 0x02, 0x46, 0x37, 0xf7, 0x55, 0x99, 0xcf, 0x08,
+	0x9b, 0x8a, 0x70, 0x01, 0xd7, 0x6c, 0x19, 0x27, 0xb9, 0xc0, 0x16, 0x9a, 0xe6, 0x67, 0x05, 0x3b,
+	0x82, 0xce, 0x82, 0x40, 0xaa, 0x6a, 0xff, 0x78, 0xbc, 0x69, 0x33, 0xeb, 0x1c, 0x39, 0x3b, 0x7b,
+	0x00, 0x6d, 0xec, 0x36, 0x1d, 0x34, 0xe8, 0x41, 0x8c, 0x76, 0xfb, 0x31, 0xb2, 0xc6, 0xf0, 0x1b,
+	0x0f, 0x5a, 0xf4, 0xd0, 0x7f, 0xcb, 0xb3, 0xbb, 0x03, 0xfe, 0x42, 0x49, 0x6e, 0x64, 0xcc, 0x8d,
+	0x6b, 0xc1, 0x9e, 0x05, 0x26, 0x66, 0xcb, 0x38, 0xbf, 0x70, 0x8d, 0xe4, 0x8c, 0xcf, 0x2e, 0xd0,
+	0x58, 0xae, 0x85, 0xfb, 0x65, 0xdb, 0xd5, 0x90, 0x80, 0x89, 0xc1, 0x50, 0x1c, 0xa5, 0x1d, 0xa2,
+	0xd4, 0x69, 0xc8, 0x67, 0xaa, 0x63, 0x9e, 0x71, 0xb5, 0xa2, 0x5e, 0xea, 0x45, 0xdd, 0x54, 0x4f,
+	0x50, 0x45, 0x93, 0x90, 0x59, 0x7c, 0x96, 0xf1, 0x84, 0xda, 0xa9, 0x17, 0x75, 0x85, 0xcc, 0x5e,
+	0x64, 0x3c, 0x09, 0x4f, 0xa1, 0x8f, 0x09, 0xce, 0x84, 0x25, 0x30, 0x84, 0x16, 0xc6, 0xef, 0xe8,
+	0xdb, 0x67, 0x85, 0x6c, 0xec, 0x1e, 0xb4, 0xb4, 0xa8, 0x99, 0x1b, 0xee, 0x8c, 0x92, 0x88, 0x4c,
+	0xe1, 0xf7, 0x0d, 0x00, 0x4b, 0x38, 0xb1, 0xb7, 0xff, 0xd0, 0x30, 0x79, 0xb2, 0xc6, 0xee, 0xd1,
+	0x62, 0xf2, 0x04, 0x4c, 0x05, 0xbb, 0x69, 0x67, 0x05, 0x9a, 0x9a, 0x1b, 0xae, 0xa7, 0x82, 0x3d,
+	0x02, 0xdf, 0xa4, 0x2b, 0x19, 0xab, 0x32, 0x93, 0x41, 0x8b, 0x2e, 0xdf, 0xaa, 0xef, 0x09, 0xbf,
+	0x78, 0x6e, 0xb2, 0xa8, 0x87, 0x2e, 0x51, 0x99, 0x49, 0x6a, 0x3f, 0xc9, 0x17, 0xc6, 0xfa, 0x5b,
+	0x16, 0x7d, 0x42, 0xc8, 0x7c, 0x0f, 0x06, 0xd6, 0x2c, 0xe4, 0x79, 0xba, 0xb0, 0x64, 0x62, 0x8b,
+	0x21, 0x76, 0x42, 0xd0, 0x0e, 0x6d, 0xdd, 0x1d, 0xda, 0xd8, 0x1f, 0xa1, 0xef, 0x2a, 0xb4, 0x45,
+	0x2a, 0x58, 0x88, 0x1c, 0x36, 0x55, 0xf2, 0x77, 0xaa, 0xc4, 0xa0, 0xa5, 0xb7, 0x5e, 0x2c, 0xca,
+	0x98, 0x71, 0xaa, 0xe3, 0xb3, 0x32, 0xcb, 0xe8, 0xc1, 0xf6, 0xa2, 0x4e, 0xaa, 0x5f, 0x94, 0x59,
+	0xc6, 0x0e, 0x61, 0x90, 0xa5, 0xf9, 0x32, 0xae, 0xf8, 0xb0, 0x4f, 0x16, 0x10, 0xa3, 0x96, 0x17,
+	0xe1, 0x3f, 0x60, 0xe4, 0x78, 0x4e, 0x57, 0x12, 0x13, 0xfd, 0xac, 0xa1, 0x76, 0x67, 0x9b, 0x49,
+	0xd7, 0x99, 0x15, 0x6f, 0xe1, 0x2b, 0xe8, 0x58, 0x2e, 0x71, 0xba, 0x0b, 0x7e, 0xe1, 0x66, 0x2d,
+	0x8a, 0xec, 0x18, 0xc0, 0xfe, 0x90, 0xe7, 0x89, 0x74, 0x0d, 0xb0, 0x3d, 0xca, 0xf1, 0x0c, 0x34,
+	0x45, 0x74, 0x3e, 0x89, 0xe1, 0x13, 0xf0, 0x6b, 0x9c, 0x16, 0xa6, 0xe1, 0xca, 0xd4, 0x0b, 0x13,
+	0x15, 0xbc, 0x48, 0xe6, 0x55, 0x27, 0xa0, 0x18, 0xbe, 0x81, 0xee, 0xeb, 0x22, 0xbb, 0x48, 0x8a,
+	0xfc, 0xb3, 0x12, 0xfa, 0x33, 0x74, 0xd6, 0x45, 0x9a, 0x9b, 0x6a, 0xbf, 0x5d, 0xdd, 0xc4, 0xf4,
+	0x1a, 0xf1, 0xc8, 0x99, 0xc3, 0x45, 0xcd, 0x17, 0xd7, 0xcb, 0x89, 0x4a, 0xf4, 0x6e, 0x2f, 0x7a,
+	0x7b, 0xbd, 0xf8, 0x14, 0x7c, 0xe2, 0x9e, 0xab, 0xa4, 0xea, 0xf7, 0x9b, 0xbb, 0x6f, 0xe2, 0x6f,
+	0xaa, 0x28, 0xd7, 0x78, 0x90, 0x7d, 0xf8, 0x28, 0x85, 0xff, 0x86, 0xe1, 0x8e, 0x69, 0xbb, 0xa5,
+	0xbd, 0x9d, 0x96, 0x7e, 0x0a, 0xfd, 0x04, 0xbd, 0xa8, 0x12, 0xfa, 0x53, 0x42, 0xe9, 0x08, 0xac,
+	0x4a, 0x04, 0x49, 0x25, 0xea, 0xf0, 0x7f, 0x1e, 0xf8, 0xb5, 0x05, 0xbb, 0xd4, 0x9e, 0x51, 0x9f,
+	0xde, 0x25, 0x7d, 0x4a, 0x03, 0xda, 0x9a, 0x8c, 0x7c, 0x6f, 0x1c, 0x61, 0x3e, 0x21, 0xa7, 0xf2,
+	0xbd, 0xc1, 0x26, 0xa6, 0x71, 0x11, 0x67, 0xf2, 0x5c, 0x66, 0x6e, 0xc5, 0x01, 0x41, 0x2f, 0x11,
+	0xc1, 0x21, 0x69, 0x03, 0x6b, 0xed, 0x0f, 0x49, 0x8a, 0xc9, 0x1a, 0xc3, 0x1f, 0x1a, 0xd0, 0x8a,
+	0x2e, 0x6b, 0xbd, 0x07, 0x30, 0x72, 0xd4, 0x56, 0xd9, 0xdb, 0x10, 0x06, 0x8b, 0xba, 0x04, 0xd3,
+	0xbd, 0x61, 0xd0, 0xdc, 0x2b, 0xc0, 0x5d, 0x80, 0xb5, 0xed, 0x03, 0xb4, 0xda, 0x39, 0xe9, 0x3b,
+	0x64, 0x2a, 0xd8, 0xef, 0xa1, 0xa3, 0x05, 0x9d, 0xdc, 0xae, 0x3f, 0xc0, 0xa6, 0x02, 0xf7, 0x07,
+	0xc2, 0x5c, 0x25, 0x31, 0xcf, 0x52, 0xae, 0xab, 0xc7, 0xad, 0x05, 0x16, 0x68, 0x82, 0x10, 0x4e,
+	0xee, 0x62, 0x2d, 0x15, 0x37, 0x85, 0xa2, 0xc7, 0xed, 0x47, 0xb5, 0xce, 0xee, 0xc3, 0xb0, 0x92,
+	0xed, 0x7e, 0xb2, 0x3b, 0x78, 0x50, 0x81, 0xd5, 0x92, 0xaa, 0x2e, 0x39, 0xe7, 0x59, 0x29, 0xdd,
+	0x5a, 0x76, 0x97, 0xbc, 0x41, 0xe8, 0xd2, 0xd7, 0x4e, 0xcb, 0x2d, 0x93, 0xf1, 0xbb, 0xd4, 0xbc,
+	0x8d, 0xd7, 0xaa, 0x5a, 0xd2, 0x7d, 0x04, 0xf1, 0x33, 0xec, 0xb5, 0xda, 0xad, 0xe9, 0x60, 0xa7,
+	0xa6, 0xe1, 0x17, 0x0d, 0x68, 0xce, 0xc4, 0xa7, 0x33, 0xf5, 0x16, 0x7d, 0xe4, 0xc5, 0x7b, 0x5f,
+	0x9d, 0x14, 0xa9, 0x33, 0xe5, 0x97, 0x7c, 0x76, 0x3e, 0x80, 0x16, 0xf5, 0xf6, 0x27, 0xe3, 0x74,
+	0x46, 0x59, 0x44, 0x64, 0xc5, 0x34, 0xd2, 0x45, 0x91, 0x3b, 0x92, 0x49, 0xc6, 0x37, 0x5b, 0xaa,
+	0xcc, 0x31, 0x8b, 0x22, 0xb6, 0x93, 0x5b, 0x69, 0xf8, 0xf8, 0x1d, 0xa9, 0x60, 0x21, 0x9c, 0x00,
+	0x5b, 0x43, 0x93, 0x1c, 0x2c, 0xa9, 0x6e, 0x68, 0x92, 0xc3, 0xce, 0x52, 0xf4, 0xf7, 0x96, 0xe2,
+	0x66, 0xa2, 0xc2, 0xfe, 0xde, 0xab, 0xa7, 0x74, 0xdf, 0x7e, 0x47, 0x54, 0xcb, 0xed, 0x83, 0x07,
+	0x1d, 0x9b, 0x08, 0x0e, 0x1e, 0xdb, 0x0a, 0x6e, 0xf0, 0x90, 0xf2, 0xab, 0x5f, 0x7c, 0xfe, 0xe6,
+	0x8b, 0x6f, 0x55, 0x6a, 0x43, 0x0d, 0xd8, 0x8b, 0x48, 0x46, 0xac, 0xcc, 0xd3, 0x6a, 0x3f, 0x93,
+	0x8c, 0xb7, 0xd8, 0xd1, 0x68, 0x69, 0xb1, 0x4a, 0xdd, 0x05, 0xdd, 0x4d, 0x17, 0x84, 0xff, 0xf7,
+	0xe0, 0xea, 0xc9, 0xfc, 0xf9, 0x5b, 0x74, 0xa8, 0xbe, 0xa6, 0xff, 0x82, 0xdf, 0x24, 0x98, 0x20,
+	0xc6, 0x38, 0x3a, 0xbe, 0xb1, 0x3d, 0x69, 0xe6, 0x99, 0xb4, 0xce, 0x22, 0xb2, 0x4e, 0xae, 0x01,
+	0x1a, 0x75, 0x03, 0x3c, 0x84, 0x0e, 0x5f, 0x98, 0xb4, 0xc8, 0x29, 0xf2, 0xd1, 0x31, 0xdb, 0xda,
+	0x8d, 0xf3, 0x09, 0x59, 0x22, 0xe7, 0x41, 0x05, 0xcd, 0xcf, 0x8a, 0xea, 0x0b, 0x16, 0xe5, 0xf0,
+	0x47, 0x0f, 0x86, 0x76, 0x36, 0xfe, 0xdc, 0xe4, 0xfd, 0xc5, 0xb5, 0x7d, 0xc9, 0xb7, 0x36, 0xfe,
+	0xa9, 0x71, 0x6f, 0xd5, 0xdd, 0x54, 0xa9, 0xb8, 0x7d, 0x8d, 0x4a, 0x93, 0x44, 0xaa, 0x38, 0x4b,
+	0xf3, 0x6a, 0x3d, 0xf7, 0x1d, 0xf6, 0x32, 0xcd, 0x25, 0xfb, 0x13, 0x8c, 0x44, 0xaa, 0x24, 0x05,
+	0x6c, 0x9d, 0x2c, 0xa9, 0xc3, 0x1a, 0x25, 0xb7, 0xaa, 0x5c, 0xdd, 0xad, 0x72, 0xdd, 0x87, 0xa1,
+	0x90, 0x67, 0x32, 0x5f, 0xc8, 0x58, 0x1b, 0x6e, 0x6c, 0xab, 0xb5, 0xa3, 0x81, 0x03, 0x67, 0x88,
+	0x3d, 0xfc, 0x0f, 0x0c, 0xb6, 0x69, 0x65, 0x03, 0xe8, 0x9d, 0xc6, 0x96, 0x80, 0xf1, 0x15, 0x36,
+	0x86, 0x41, 0xa5, 0xe1, 0x9c, 0x1a, 0x7b, 0xec, 0x3a, 0x8c, 0xb7, 0x11, 0x1c, 0xec, 0xe3, 0x06,
+	0x03, 0xe8, 0x9c, 0xc6, 0xe4, 0xd1, 0x64, 0x43, 0xf0, 0xad, 0x3c, 0x13, 0xcb, 0x71, 0x8b, 0x5d,
+	0x83, 0x61, 0xad, 0xe2, 0x7c, 0x1c, 0xb7, 0x99, 0x0f, 0xed, 0xd3, 0x18, 0xad, 0x9d, 0x87, 0x8f,
+	0xa1, 0x57, 0x95, 0x05, 0x0f, 0x99, 0xe6, 0x5a, 0x2a, 0x33, 0xbe, 0x82, 0xf2, 0x3f, 0xe9, 0x45,
+	0x8c, 0x3d, 0x94, 0x4f, 0x64, 0x26, 0x8d, 0x1c, 0x37, 0x9e, 0x8d, 0xbf, 0xfa, 0x78, 0xe0, 0x7d,
+	0xfd, 0xf1, 0xc0, 0xfb, 0xf6, 0xe3, 0x81, 0xf7, 0xe1, 0xbb, 0x83, 0x2b, 0xf3, 0x0e, 0xd5, 0xf7,
+	0xc9, 0x4f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x0d, 0xf3, 0xa8, 0xf0, 0xbd, 0x0e, 0x00, 0x00,
 }
+
+func (m *SdkmsgWithTask) 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 *SdkmsgWithTask) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Sdkid) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Sdkid)))
+		i += copy(dAtA[i:], m.Sdkid)
+	}
+	if len(m.Sdktype) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Sdktype)))
+		i += copy(dAtA[i:], m.Sdktype)
+	}
+	if len(m.SdkName) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkName)))
+		i += copy(dAtA[i:], m.SdkName)
+	}
+	if len(m.Sdkdata) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Sdkdata)))
+		i += copy(dAtA[i:], m.Sdkdata)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *TaskLabel) 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 *TaskLabel) 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.Taskname) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Taskname)))
+		i += copy(dAtA[i:], m.Taskname)
+	}
+	if len(m.Sdkinfos) > 0 {
+		for _, msg := range m.Sdkinfos {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.Index != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Index))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *SdkMessage) 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 *SdkMessage) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Cid) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Cid)))
+		i += copy(dAtA[i:], m.Cid)
+	}
+	if len(m.Caddr) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Caddr)))
+		i += copy(dAtA[i:], m.Caddr)
+	}
+	if m.Tasklab != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Tasklab.Size()))
+		n1, err1 := m.Tasklab.MarshalTo(dAtA[i:])
+		if err1 != nil {
+			return 0, err1
+		}
+		i += n1
+	}
+	if len(m.Data) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
+		i += copy(dAtA[i:], m.Data)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Area) 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 *Area) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Id != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Id))
+	}
+	if m.Parentid != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Parentid))
+	}
+	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.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Camera) 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 *Camera) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Id) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
+		i += copy(dAtA[i:], m.Id)
+	}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if m.Type != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Type))
+	}
+	if len(m.Addr) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Addr)))
+		i += copy(dAtA[i:], m.Addr)
+	}
+	if m.Areaid != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Areaid))
+	}
+	if m.Longitude != 0 {
+		dAtA[i] = 0x35
+		i++
+		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Longitude))))
+		i += 4
+	}
+	if m.Latitude != 0 {
+		dAtA[i] = 0x3d
+		i++
+		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Latitude))))
+		i += 4
+	}
+	if len(m.Rtsp) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Rtsp)))
+		i += copy(dAtA[i:], m.Rtsp)
+	}
+	if len(m.Ip) > 0 {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Ip)))
+		i += copy(dAtA[i:], m.Ip)
+	}
+	if m.Port != 0 {
+		dAtA[i] = 0x50
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Port))
+	}
+	if len(m.Username) > 0 {
+		dAtA[i] = 0x5a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Username)))
+		i += copy(dAtA[i:], m.Username)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x62
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	if len(m.Brand) > 0 {
+		dAtA[i] = 0x6a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Brand)))
+		i += copy(dAtA[i:], m.Brand)
+	}
+	if len(m.Reserved) > 0 {
+		dAtA[i] = 0x72
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Reserved)))
+		i += copy(dAtA[i:], m.Reserved)
+	}
+	if m.IsRunning {
+		dAtA[i] = 0x78
+		i++
+		if m.IsRunning {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.RunEnable {
+		dAtA[i] = 0x80
+		i++
+		dAtA[i] = 0x1
+		i++
+		if m.RunEnable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.RunType != 0 {
+		dAtA[i] = 0x88
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.RunType))
+	}
+	if len(m.RunServerId) > 0 {
+		dAtA[i] = 0x92
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RunServerId)))
+		i += copy(dAtA[i:], m.RunServerId)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *CameraAndTaskInfo) 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 *CameraAndTaskInfo) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Camera != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Camera.Size()))
+		n2, err2 := m.Camera.MarshalTo(dAtA[i:])
+		if err2 != nil {
+			return 0, err2
+		}
+		i += n2
+	}
+	if len(m.Tasks) > 0 {
+		for _, msg := range m.Tasks {
+			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
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Task) 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 *Task) 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.Taskname) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Taskname)))
+		i += copy(dAtA[i:], m.Taskname)
+	}
+	if len(m.CreateAt) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateAt)))
+		i += copy(dAtA[i:], m.CreateAt)
+	}
+	if len(m.CreateBy) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateBy)))
+		i += copy(dAtA[i:], m.CreateBy)
+	}
+	if len(m.UpdateAt) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.UpdateAt)))
+		i += copy(dAtA[i:], m.UpdateAt)
+	}
+	if m.Enable {
+		dAtA[i] = 0x30
+		i++
+		if m.Enable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.IsAlarm {
+		dAtA[i] = 0x38
+		i++
+		if m.IsAlarm {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.DelFlag {
+		dAtA[i] = 0x40
+		i++
+		if m.DelFlag {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *TaskSdkInfo) 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 *TaskSdkInfo) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Task != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Task.Size()))
+		n3, err3 := m.Task.MarshalTo(dAtA[i:])
+		if err3 != nil {
+			return 0, err3
+		}
+		i += n3
+	}
+	if len(m.Sdks) > 0 {
+		for _, msg := range m.Sdks {
+			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
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *CameraTask) 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 *CameraTask) 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.TaskId) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TaskId)))
+		i += copy(dAtA[i:], m.TaskId)
+	}
+	if len(m.TimeRule) > 0 {
+		for _, msg := range m.TimeRule {
+			dAtA[i] = 0x22
+			i++
+			i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if len(m.ReactRule) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ReactRule)))
+		i += copy(dAtA[i:], m.ReactRule)
+	}
+	if len(m.ReactDevice) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.ReactDevice)))
+		i += copy(dAtA[i:], m.ReactDevice)
+	}
+	if m.DelFlag {
+		dAtA[i] = 0x38
+		i++
+		if m.DelFlag {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.UpdateFlag {
+		dAtA[i] = 0x40
+		i++
+		if m.UpdateFlag {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.Enable {
+		dAtA[i] = 0x48
+		i++
+		if m.Enable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.Sort != 0 {
+		dAtA[i] = 0x50
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
+	}
+	if m.IsFull {
+		dAtA[i] = 0x58
+		i++
+		if m.IsFull {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if len(m.LinkTaskId) > 0 {
+		dAtA[i] = 0x62
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.LinkTaskId)))
+		i += copy(dAtA[i:], m.LinkTaskId)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *CameraTimerule) 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 *CameraTimerule) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Id) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
+		i += copy(dAtA[i:], m.Id)
+	}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.TimeRule) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.TimeRule)))
+		i += copy(dAtA[i:], m.TimeRule)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *DayCtl) 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 *DayCtl) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Day != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Day))
+	}
+	if len(m.TimeRange) > 0 {
+		for _, msg := range m.TimeRange {
+			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
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *TimeRange) 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 *TimeRange) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Start) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Start)))
+		i += copy(dAtA[i:], m.Start)
+	}
+	if len(m.End) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.End)))
+		i += copy(dAtA[i:], m.End)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Polygon) 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 *Polygon) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Id) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
+		i += copy(dAtA[i:], m.Id)
+	}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Points) > 0 {
+		for _, msg := range m.Points {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *CameraTaskArgs) 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 *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
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	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
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	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.GroupText) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupText)))
+		i += copy(dAtA[i:], m.GroupText)
+	}
+	if m.AlarmLevel != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.AlarmLevel))
+	}
+	if len(m.Rules) > 0 {
+		for _, msg := range m.Rules {
+			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
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	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
+	_ = 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.CameraTaskId) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraTaskId)))
+		i += copy(dAtA[i:], m.CameraTaskId)
+	}
+	if len(m.CameraId) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CameraId)))
+		i += copy(dAtA[i:], m.CameraId)
+	}
+	if len(m.PolygonId) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.PolygonId)))
+		i += copy(dAtA[i:], m.PolygonId)
+	}
+	if len(m.SdkId) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkId)))
+		i += copy(dAtA[i:], m.SdkId)
+	}
+	if len(m.SdkArgAlias) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgAlias)))
+		i += copy(dAtA[i:], m.SdkArgAlias)
+	}
+	if len(m.Operator) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Operator)))
+		i += copy(dAtA[i:], m.Operator)
+	}
+	if len(m.OperatorType) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.OperatorType)))
+		i += copy(dAtA[i:], m.OperatorType)
+	}
+	if len(m.SdkArgValue) > 0 {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkArgValue)))
+		i += copy(dAtA[i:], m.SdkArgValue)
+	}
+	if m.Sort != 0 {
+		dAtA[i] = 0x50
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
+	}
+	if len(m.RuleWithPre) > 0 {
+		dAtA[i] = 0x5a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.RuleWithPre)))
+		i += copy(dAtA[i:], m.RuleWithPre)
+	}
+	if len(m.GroupId) > 0 {
+		dAtA[i] = 0x62
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.GroupId)))
+		i += copy(dAtA[i:], m.GroupId)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Sdk) 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 *Sdk) 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.SdkType) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkType)))
+		i += copy(dAtA[i:], m.SdkType)
+	}
+	if len(m.SdkName) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkName)))
+		i += copy(dAtA[i:], m.SdkName)
+	}
+	if len(m.Args) > 0 {
+		for _, msg := range m.Args {
+			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
+		}
+	}
+	if len(m.Icon) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Icon)))
+		i += copy(dAtA[i:], m.Icon)
+	}
+	if len(m.Url) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Url)))
+		i += copy(dAtA[i:], m.Url)
+	}
+	if len(m.CreateTime) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateTime)))
+		i += copy(dAtA[i:], m.CreateTime)
+	}
+	if len(m.UpdateTime) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.UpdateTime)))
+		i += copy(dAtA[i:], m.UpdateTime)
+	}
+	if len(m.CreateBy) > 0 {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateBy)))
+		i += copy(dAtA[i:], m.CreateBy)
+	}
+	if m.Enable {
+		dAtA[i] = 0x50
+		i++
+		if m.Enable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.DelFlag != 0 {
+		dAtA[i] = 0x58
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.DelFlag))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *SdkArg) 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 *SdkArg) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Alias) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Alias)))
+		i += copy(dAtA[i:], m.Alias)
+	}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Type) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Type)))
+		i += copy(dAtA[i:], m.Type)
+	}
+	if m.Must {
+		dAtA[i] = 0x20
+		i++
+		if m.Must {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if len(m.Unit) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Unit)))
+		i += copy(dAtA[i:], m.Unit)
+	}
+	if len(m.Range) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Range)))
+		i += copy(dAtA[i:], m.Range)
+	}
+	if m.Sort != 0 {
+		dAtA[i] = 0x38
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Sort))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *DbChangeMessage) 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 *DbChangeMessage) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Table != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Table))
+	}
+	if len(m.Id) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
+		i += copy(dAtA[i:], m.Id)
+	}
+	if m.Action != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(m.Action))
+	}
+	if len(m.Info) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Info)))
+		i += copy(dAtA[i:], m.Info)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	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))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *SdkmsgWithTask) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Sdkid)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Sdktype)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.SdkName)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Sdkdata)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *TaskLabel) 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))
+	}
+	l = len(m.Taskname)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if len(m.Sdkinfos) > 0 {
+		for _, e := range m.Sdkinfos {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	if m.Index != 0 {
+		n += 1 + sovProtomsg(uint64(m.Index))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *SdkMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Cid)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Caddr)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Tasklab != nil {
+		l = m.Tasklab.Size()
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Data)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Area) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Id != 0 {
+		n += 1 + sovProtomsg(uint64(m.Id))
+	}
+	if m.Parentid != 0 {
+		n += 1 + sovProtomsg(uint64(m.Parentid))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Camera) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Id)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Type != 0 {
+		n += 1 + sovProtomsg(uint64(m.Type))
+	}
+	l = len(m.Addr)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Areaid != 0 {
+		n += 1 + sovProtomsg(uint64(m.Areaid))
+	}
+	if m.Longitude != 0 {
+		n += 5
+	}
+	if m.Latitude != 0 {
+		n += 5
+	}
+	l = len(m.Rtsp)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Ip)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Port != 0 {
+		n += 1 + sovProtomsg(uint64(m.Port))
+	}
+	l = len(m.Username)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Brand)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Reserved)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.IsRunning {
+		n += 2
+	}
+	if m.RunEnable {
+		n += 3
+	}
+	if m.RunType != 0 {
+		n += 2 + sovProtomsg(uint64(m.RunType))
+	}
+	l = len(m.RunServerId)
+	if l > 0 {
+		n += 2 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *CameraAndTaskInfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Camera != nil {
+		l = m.Camera.Size()
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if len(m.Tasks) > 0 {
+		for _, e := range m.Tasks {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Task) 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))
+	}
+	l = len(m.Taskname)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.CreateAt)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.CreateBy)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.UpdateAt)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Enable {
+		n += 2
+	}
+	if m.IsAlarm {
+		n += 2
+	}
+	if m.DelFlag {
+		n += 2
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *TaskSdkInfo) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Task != nil {
+		l = m.Task.Size()
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if len(m.Sdks) > 0 {
+		for _, e := range m.Sdks {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *CameraTask) 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.TaskId)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if len(m.TimeRule) > 0 {
+		for _, e := range m.TimeRule {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	l = len(m.ReactRule)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.ReactDevice)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.DelFlag {
+		n += 2
+	}
+	if m.UpdateFlag {
+		n += 2
+	}
+	if m.Enable {
+		n += 2
+	}
+	if m.Sort != 0 {
+		n += 1 + sovProtomsg(uint64(m.Sort))
+	}
+	if m.IsFull {
+		n += 2
+	}
+	l = len(m.LinkTaskId)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *CameraTimerule) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Id)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.TimeRule)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *DayCtl) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Day != 0 {
+		n += 1 + sovProtomsg(uint64(m.Day))
+	}
+	if len(m.TimeRange) > 0 {
+		for _, e := range m.TimeRange {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *TimeRange) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Start)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.End)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Polygon) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Id)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if len(m.Points) > 0 {
+		for _, e := range m.Points {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *CameraTaskArgs) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	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))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	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))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	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))
+	}
+	l = len(m.GroupText)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.AlarmLevel != 0 {
+		n += 1 + sovProtomsg(uint64(m.AlarmLevel))
+	}
+	if len(m.Rules) > 0 {
+		for _, e := range m.Rules {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	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))
+	}
+	l = len(m.CameraTaskId)
+	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.PolygonId)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.SdkId)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.SdkArgAlias)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Operator)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.OperatorType)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.SdkArgValue)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Sort != 0 {
+		n += 1 + sovProtomsg(uint64(m.Sort))
+	}
+	l = len(m.RuleWithPre)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.GroupId)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Sdk) 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.SdkType)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.SdkName)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if len(m.Args) > 0 {
+		for _, e := range m.Args {
+			l = e.Size()
+			n += 1 + l + sovProtomsg(uint64(l))
+		}
+	}
+	l = len(m.Icon)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Url)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.CreateTime)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.UpdateTime)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.CreateBy)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Enable {
+		n += 2
+	}
+	if m.DelFlag != 0 {
+		n += 1 + sovProtomsg(uint64(m.DelFlag))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *SdkArg) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Alias)
+	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.Type)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Must {
+		n += 2
+	}
+	l = len(m.Unit)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	l = len(m.Range)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Sort != 0 {
+		n += 1 + sovProtomsg(uint64(m.Sort))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *DbChangeMessage) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Table != 0 {
+		n += 1 + sovProtomsg(uint64(m.Table))
+	}
+	l = len(m.Id)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.Action != 0 {
+		n += 1 + sovProtomsg(uint64(m.Action))
+	}
+	l = len(m.Info)
+	if l > 0 {
+		n += 1 + l + sovProtomsg(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	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))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func sovProtomsg(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozProtomsg(x uint64) (n int) {
+	return sovProtomsg(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *SdkmsgWithTask) 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: SdkmsgWithTask: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SdkmsgWithTask: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sdkid", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Sdkid = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sdktype", 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.Sdktype = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SdkName", 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.SdkName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sdkdata", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Sdkdata = append(m.Sdkdata[:0], dAtA[iNdEx:postIndex]...)
+			if m.Sdkdata == nil {
+				m.Sdkdata = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TaskLabel) 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: TaskLabel: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TaskLabel: 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 Taskname", 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.Taskname = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sdkinfos", 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.Sdkinfos = append(m.Sdkinfos, &SdkmsgWithTask{})
+			if err := m.Sdkinfos[len(m.Sdkinfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
+			}
+			m.Index = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Index |= 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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SdkMessage) 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: SdkMessage: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SdkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Cid", 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.Cid = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Caddr", 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.Caddr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Tasklab", 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.Tasklab == nil {
+				m.Tasklab = &TaskLabel{}
+			}
+			if err := m.Tasklab.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+			if m.Data == nil {
+				m.Data = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Area) 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: Area: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Area: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+			}
+			m.Id = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Id |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Parentid", wireType)
+			}
+			m.Parentid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Parentid |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		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
+		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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Camera) 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: Camera: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Camera: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Id = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addr", 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.Addr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Areaid", wireType)
+			}
+			m.Areaid = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Areaid |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.Longitude = float32(math.Float32frombits(v))
+		case 7:
+			if wireType != 5 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
+			}
+			var v uint32
+			if (iNdEx + 4) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+			iNdEx += 4
+			m.Latitude = float32(math.Float32frombits(v))
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Rtsp", 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.Rtsp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ip", 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.Ip = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
+			}
+			m.Port = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Port |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Username", 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.Username = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 12:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", 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.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 13:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Brand", 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.Brand = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 14:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", 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.Reserved = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsRunning", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IsRunning = bool(v != 0)
+		case 16:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RunEnable", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RunEnable = bool(v != 0)
+		case 17:
+			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
+				}
+			}
+		case 18:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RunServerId", 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.RunServerId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CameraAndTaskInfo) 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: CameraAndTaskInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CameraAndTaskInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Camera", 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.Camera == nil {
+				m.Camera = &Camera{}
+			}
+			if err := m.Camera.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Tasks", 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.Tasks = append(m.Tasks, &Task{})
+			if err := m.Tasks[len(m.Tasks)-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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Task) 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: Task: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Task: 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 Taskname", 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.Taskname = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", 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.CreateAt = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateBy", 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.CreateBy = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UpdateAt", 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.UpdateAt = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Enable = bool(v != 0)
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsAlarm", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IsAlarm = bool(v != 0)
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.DelFlag = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TaskSdkInfo) 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: TaskSdkInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TaskSdkInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Task", 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.Task == nil {
+				m.Task = &Task{}
+			}
+			if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sdks", 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.Sdks = append(m.Sdks, &Sdk{})
+			if err := m.Sdks[len(m.Sdks)-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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CameraTask) 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: CameraTask: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CameraTask: 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 TaskId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TaskId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 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
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReactRule", 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.ReactRule = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ReactDevice", 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.ReactDevice = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.DelFlag = bool(v != 0)
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UpdateFlag", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.UpdateFlag = bool(v != 0)
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Enable = bool(v != 0)
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
+			}
+			m.Sort = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Sort |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsFull", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IsFull = bool(v != 0)
+		case 12:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LinkTaskId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.LinkTaskId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CameraTimerule) 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: CameraTimerule: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CameraTimerule: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Id = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeRule", 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.TimeRule = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DayCtl) 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: DayCtl: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DayCtl: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Day", wireType)
+			}
+			m.Day = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Day |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimeRange", 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.TimeRange = append(m.TimeRange, &TimeRange{})
+			if err := m.TimeRange[len(m.TimeRange)-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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TimeRange) 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: TimeRange: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TimeRange: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Start", 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.Start = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field End", 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.End = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Polygon) 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: Polygon: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Polygon: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Id = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Points", 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.Points = append(m.Points, &Point{})
+			if err := m.Points[len(m.Points)-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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CameraTaskArgs) 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: CameraTaskArgs: wiretype end group for non-group")
+		}
+		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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			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 GroupText", 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.GroupText = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AlarmLevel", wireType)
+			}
+			m.AlarmLevel = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.AlarmLevel |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			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:
+			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 CameraTaskId", 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.CameraTaskId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			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 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PolygonId", 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.PolygonId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SdkId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SdkId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SdkArgAlias", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SdkArgAlias = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Operator = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OperatorType", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.OperatorType = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SdkArgValue", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SdkArgValue = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
+			}
+			m.Sort = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Sort |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", 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.RuleWithPre = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 12:
+			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
+		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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Sdk) 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: Sdk: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Sdk: 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 SdkType", 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.SdkType = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SdkName", 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.SdkName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Args", 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.Args = append(m.Args, &SdkArg{})
+			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Icon", 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.Icon = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Url = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", 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.CreateTime = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", 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.UpdateTime = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateBy", 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.CreateBy = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Enable = bool(v != 0)
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", wireType)
+			}
+			m.DelFlag = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DelFlag |= 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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SdkArg) 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: SdkArg: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SdkArg: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alias", 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.Alias = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field 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 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Must", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Must = bool(v != 0)
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Unit", 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.Unit = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Range", 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.Range = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
+			}
+			m.Sort = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Sort |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DbChangeMessage) 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: DbChangeMessage: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DbChangeMessage: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
+			}
+			m.Table = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Table |= TableChanged(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		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 != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
+			}
+			m.Action = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Action |= DbAction(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipProtomsg(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthProtomsg
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	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
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipProtomsg(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowProtomsg
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowProtomsg
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthProtomsg
+			}
+			iNdEx += length
+			if iNdEx < 0 {
+				return 0, ErrInvalidLengthProtomsg
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowProtomsg
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipProtomsg(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+				if iNdEx < 0 {
+					return 0, ErrInvalidLengthProtomsg
+				}
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthProtomsg = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowProtomsg   = fmt.Errorf("proto: integer overflow")
+)
diff --git a/sdk.pb.go b/sdk.pb.go
index bf112d9..0fc61b4 100644
--- a/sdk.pb.go
+++ b/sdk.pb.go
@@ -6,7 +6,7 @@
 import (
 	encoding_binary "encoding/binary"
 	fmt "fmt"
-	proto "github.com/gogo/protobuf/proto"
+	proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 )
@@ -20,15 +20,18 @@
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 // Image ipc struct
 type Image struct {
-	Width     int32  `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
-	Height    int32  `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
-	Data      []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
-	Timestamp string `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
-	Id        int64  `protobuf:"varint,5,opt,name=id,proto3" json:"id,omitempty"`
+	Width                int32    `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
+	Height               int32    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
+	Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+	Timestamp            string   `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	Id                   int64    `protobuf:"varint,5,opt,name=id,proto3" json:"id,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *Image) Reset()         { *m = Image{} }
@@ -100,10 +103,13 @@
 }
 
 type FaceAngle struct {
-	Yaw        int32   `protobuf:"varint,1,opt,name=yaw,proto3" json:"yaw,omitempty"`
-	Pitch      int32   `protobuf:"varint,2,opt,name=pitch,proto3" json:"pitch,omitempty"`
-	Roll       int32   `protobuf:"varint,3,opt,name=roll,proto3" json:"roll,omitempty"`
-	Confidence float32 `protobuf:"fixed32,4,opt,name=confidence,proto3" json:"confidence,omitempty"`
+	Yaw                  int32    `protobuf:"varint,1,opt,name=yaw,proto3" json:"yaw,omitempty"`
+	Pitch                int32    `protobuf:"varint,2,opt,name=pitch,proto3" json:"pitch,omitempty"`
+	Roll                 int32    `protobuf:"varint,3,opt,name=roll,proto3" json:"roll,omitempty"`
+	Confidence           float32  `protobuf:"fixed32,4,opt,name=confidence,proto3" json:"confidence,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *FaceAngle) Reset()         { *m = FaceAngle{} }
@@ -168,11 +174,14 @@
 }
 
 type ThftResult struct {
-	Gender int32 `protobuf:"varint,1,opt,name=gender,proto3" json:"gender,omitempty"`
-	Age    int32 `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
-	Race   int32 `protobuf:"varint,3,opt,name=race,proto3" json:"race,omitempty"`
-	Beauty int32 `protobuf:"varint,4,opt,name=beauty,proto3" json:"beauty,omitempty"`
-	Smile  int32 `protobuf:"varint,5,opt,name=smile,proto3" json:"smile,omitempty"`
+	Gender               int32    `protobuf:"varint,1,opt,name=gender,proto3" json:"gender,omitempty"`
+	Age                  int32    `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
+	Race                 int32    `protobuf:"varint,3,opt,name=race,proto3" json:"race,omitempty"`
+	Beauty               int32    `protobuf:"varint,4,opt,name=beauty,proto3" json:"beauty,omitempty"`
+	Smile                int32    `protobuf:"varint,5,opt,name=smile,proto3" json:"smile,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ThftResult) Reset()         { *m = ThftResult{} }
@@ -244,14 +253,17 @@
 }
 
 type FacePos struct {
-	RcFace     *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
-	PtLeftEye  *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
-	PtRightEye *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
-	PtMouth    *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
-	PtNose     *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
-	FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
-	Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
-	FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
+	RcFace               *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
+	PtLeftEye            *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
+	PtRightEye           *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
+	PtMouth              *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
+	PtNose               *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
+	FAngle               *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
+	Quality              int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
+	FacialData           []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
 }
 
 func (m *FacePos) Reset()         { *m = FacePos{} }
@@ -344,15 +356,18 @@
 }
 
 type FaceInfo struct {
-	RcFace     *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
-	PtLeftEye  *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
-	PtRightEye *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
-	PtMouth    *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
-	PtNose     *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
-	FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
-	Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
-	FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
-	FaceID     int64      `protobuf:"varint,9,opt,name=faceID,proto3" json:"faceID,omitempty"`
+	RcFace               *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
+	PtLeftEye            *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
+	PtRightEye           *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
+	PtMouth              *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
+	PtNose               *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
+	FAngle               *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
+	Quality              int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
+	FacialData           []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
+	FaceID               int64      `protobuf:"varint,9,opt,name=faceID,proto3" json:"faceID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
 }
 
 func (m *FaceInfo) Reset()         { *m = FaceInfo{} }
@@ -452,9 +467,12 @@
 }
 
 type ObjInfo struct {
-	RcObj *Rect   `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
-	Typ   int32   `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
-	Prob  float32 `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
+	RcObj                *Rect    `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
+	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
+	Prob                 float32  `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ObjInfo) Reset()         { *m = ObjInfo{} }
@@ -513,8 +531,11 @@
 
 // sdk face property
 type ResultFaceDetect struct {
-	Pos    *FacePos    `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
-	Result *ThftResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
+	Pos                  *FacePos    `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
+	Result               *ThftResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
 }
 
 func (m *ResultFaceDetect) Reset()         { *m = ResultFaceDetect{} }
@@ -565,7 +586,10 @@
 }
 
 type ParamFacePos struct {
-	Faces []*ResultFaceDetect `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
+	Faces                []*ResultFaceDetect `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
+	XXX_unrecognized     []byte              `json:"-"`
+	XXX_sizecache        int32               `json:"-"`
 }
 
 func (m *ParamFacePos) Reset()         { *m = ParamFacePos{} }
@@ -609,7 +633,10 @@
 }
 
 type ParamFaceFeature struct {
-	Feats [][]byte `protobuf:"bytes,1,rep,name=feats,proto3" json:"feats,omitempty"`
+	Feats                [][]byte `protobuf:"bytes,1,rep,name=feats,proto3" json:"feats,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ParamFaceFeature) Reset()         { *m = ParamFaceFeature{} }
@@ -654,8 +681,11 @@
 
 // sdk face extract
 type ParamFaceCompare struct {
-	Feat1 []byte `protobuf:"bytes,1,opt,name=feat1,proto3" json:"feat1,omitempty"`
-	Feat2 []byte `protobuf:"bytes,2,opt,name=feat2,proto3" json:"feat2,omitempty"`
+	Feat1                []byte   `protobuf:"bytes,1,opt,name=feat1,proto3" json:"feat1,omitempty"`
+	Feat2                []byte   `protobuf:"bytes,2,opt,name=feat2,proto3" json:"feat2,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ParamFaceCompare) Reset()         { *m = ParamFaceCompare{} }
@@ -707,7 +737,10 @@
 
 // sdk yolo detect
 type ParamYoloObj struct {
-	Infos []*ObjInfo `protobuf:"bytes,1,rep,name=infos,proto3" json:"infos,omitempty"`
+	Infos                []*ObjInfo `protobuf:"bytes,1,rep,name=infos,proto3" json:"infos,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
 }
 
 func (m *ParamYoloObj) Reset()         { *m = ParamYoloObj{} }
@@ -767,48 +800,47 @@
 func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }
 
 var fileDescriptor_70decb0fb6f436df = []byte{
-	// 650 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0x4f, 0x6f, 0xd3, 0x4e,
-	0x10, 0xad, 0x9d, 0xda, 0x69, 0xa6, 0x55, 0x7f, 0xfd, 0x2d, 0x15, 0xb2, 0x2a, 0x64, 0x45, 0x06,
-	0xd1, 0x20, 0xa0, 0xd0, 0x70, 0xe0, 0x86, 0xf8, 0x53, 0x2a, 0x55, 0x02, 0x1a, 0xad, 0xe0, 0xc0,
-	0x71, 0x63, 0xaf, 0x1d, 0x17, 0xdb, 0x6b, 0xec, 0x89, 0x4a, 0xbe, 0x05, 0x1f, 0x8b, 0x03, 0x87,
-	0x1e, 0x39, 0xa2, 0x56, 0x7c, 0x0f, 0xb4, 0xe3, 0x75, 0x9d, 0x4a, 0xe5, 0xc4, 0x95, 0x53, 0xf6,
-	0xcd, 0x3c, 0xef, 0x9b, 0x37, 0xb3, 0x13, 0x18, 0xd4, 0xd1, 0xa7, 0xbd, 0xb2, 0x52, 0xa8, 0xd8,
-	0x1a, 0xfd, 0xe4, 0x75, 0xb2, 0x03, 0x53, 0x51, 0xcb, 0x26, 0x1a, 0x9c, 0x82, 0x73, 0x94, 0x8b,
-	0x44, 0xb2, 0x6d, 0x70, 0x4e, 0xd3, 0x08, 0x67, 0x9e, 0x35, 0xb4, 0x46, 0x0e, 0x6f, 0x00, 0xbb,
-	0x09, 0xee, 0x4c, 0xa6, 0xc9, 0x0c, 0x3d, 0x9b, 0xc2, 0x06, 0x31, 0x06, 0xab, 0x91, 0x40, 0xe1,
-	0xf5, 0x86, 0xd6, 0x68, 0x83, 0xd3, 0x99, 0xdd, 0x82, 0x01, 0xa6, 0xb9, 0xac, 0x51, 0xe4, 0xa5,
-	0xb7, 0x3a, 0xb4, 0x46, 0x03, 0xde, 0x05, 0xd8, 0x26, 0xd8, 0x69, 0xe4, 0x39, 0x43, 0x6b, 0xd4,
-	0xe3, 0x76, 0x1a, 0x05, 0x09, 0x0c, 0x0e, 0x45, 0x28, 0x5f, 0x14, 0x49, 0x26, 0xd9, 0x16, 0xf4,
-	0x16, 0xe2, 0xd4, 0x48, 0xeb, 0xa3, 0x2e, 0xa7, 0x4c, 0x31, 0x9c, 0x19, 0xdd, 0x06, 0x68, 0xd9,
-	0x4a, 0x65, 0x19, 0xc9, 0x3a, 0x9c, 0xce, 0xcc, 0x07, 0x08, 0x55, 0x11, 0xa7, 0x91, 0x2c, 0x42,
-	0x49, 0xba, 0x36, 0x5f, 0x8a, 0x04, 0x5f, 0x00, 0xde, 0xcf, 0x62, 0xe4, 0xb2, 0x9e, 0x67, 0xa8,
-	0x0d, 0x25, 0xb2, 0x88, 0x64, 0x65, 0xc4, 0x0c, 0xd2, 0x15, 0x88, 0x44, 0x1a, 0x35, 0x7d, 0x24,
-	0x2d, 0x11, 0xca, 0x4b, 0x2d, 0x11, 0x4a, 0xfd, 0xf5, 0x54, 0x8a, 0x39, 0x2e, 0x48, 0xc7, 0xe1,
-	0x06, 0xe9, 0x6a, 0xeb, 0x3c, 0xcd, 0x24, 0xf9, 0x73, 0x78, 0x03, 0x82, 0xef, 0x36, 0xf4, 0xb5,
-	0xc7, 0x89, 0xaa, 0xd9, 0x5d, 0x70, 0xab, 0x50, 0x03, 0xd2, 0x5d, 0x1f, 0x6f, 0xee, 0xb5, 0xe3,
-	0xd8, 0xe3, 0x32, 0x44, 0x6e, 0xb2, 0xec, 0x21, 0x0c, 0x4a, 0x7c, 0x23, 0x63, 0x7c, 0xbd, 0x68,
-	0xaa, 0x59, 0x1f, 0xff, 0xd7, 0x51, 0x27, 0x2a, 0x2d, 0x90, 0x77, 0x0c, 0xf6, 0x08, 0xa0, 0x44,
-	0xae, 0x47, 0xa2, 0xf9, 0xbd, 0xeb, 0xf9, 0x4b, 0x14, 0x76, 0x0f, 0xfa, 0x25, 0xbe, 0x55, 0x73,
-	0x9c, 0x91, 0x85, 0x6b, 0xd8, 0x6d, 0x9e, 0xed, 0x82, 0x5b, 0xe2, 0x3b, 0x55, 0x37, 0xae, 0xae,
-	0x61, 0x9a, 0x34, 0xbb, 0x0f, 0x6e, 0x4c, 0x73, 0xf4, 0x5c, 0x22, 0xde, 0xe8, 0x88, 0x97, 0x23,
-	0xe6, 0x86, 0xc2, 0x3c, 0xe8, 0x7f, 0x9e, 0x8b, 0x2c, 0xc5, 0x85, 0xd7, 0xa7, 0x66, 0xb5, 0x50,
-	0x0f, 0x32, 0x16, 0x61, 0x2a, 0xb2, 0x03, 0xfd, 0xb2, 0xd6, 0xe8, 0x65, 0x2d, 0x45, 0x82, 0x5f,
-	0x36, 0xac, 0xe9, 0xfb, 0x8e, 0x8a, 0x58, 0xfd, 0xeb, 0xe7, 0x5f, 0xf7, 0x53, 0x3f, 0xe6, 0x58,
-	0xb7, 0xf3, 0xc0, 0x1b, 0xd0, 0x56, 0x1a, 0x14, 0x7c, 0x80, 0xfe, 0xf1, 0xf4, 0x84, 0xba, 0x7c,
-	0x07, 0x9c, 0x2a, 0x3c, 0x9e, 0x9e, 0xfc, 0xa1, 0xc9, 0x4d, 0x52, 0xef, 0x0e, 0x2e, 0xca, 0x76,
-	0x77, 0x70, 0x51, 0xea, 0xdd, 0x29, 0x2b, 0x35, 0xa5, 0x06, 0xda, 0x9c, 0xce, 0x81, 0x84, 0xad,
-	0x66, 0x07, 0xb5, 0x87, 0x03, 0x89, 0x32, 0x44, 0x76, 0x1b, 0x7a, 0xa5, 0xaa, 0xcd, 0xed, 0xff,
-	0x5f, 0xb5, 0x39, 0x51, 0x35, 0xd7, 0x59, 0xf6, 0x00, 0xdc, 0x8a, 0x3e, 0x34, 0xf3, 0xdb, 0xee,
-	0x78, 0xdd, 0x62, 0x73, 0xc3, 0x09, 0x9e, 0xc3, 0xc6, 0x44, 0x54, 0x22, 0x6f, 0x17, 0xef, 0x31,
-	0x38, 0xda, 0x97, 0x16, 0xe9, 0x8d, 0xd6, 0xc7, 0x3b, 0xcb, 0x16, 0xae, 0x56, 0xc3, 0x1b, 0x62,
-	0x30, 0x82, 0xad, 0xcb, 0x1b, 0x0e, 0xa5, 0xc0, 0x79, 0x45, 0xff, 0x8e, 0xb1, 0x14, 0xd8, 0xdc,
-	0xb2, 0xc1, 0x1b, 0x10, 0x3c, 0x5b, 0x62, 0xbe, 0x52, 0x79, 0x29, 0x3a, 0xe6, 0x3e, 0x99, 0x32,
-	0xcc, 0xfd, 0x36, 0x3a, 0x26, 0x0b, 0x26, 0x3a, 0x0e, 0x9e, 0x9a, 0x5a, 0x3f, 0xaa, 0x4c, 0xe9,
-	0x46, 0xee, 0x82, 0x93, 0x16, 0xb1, 0x6a, 0x6b, 0x5d, 0x6a, 0x88, 0x19, 0x08, 0x6f, 0xf2, 0x2f,
-	0xbd, 0x6f, 0xe7, 0xbe, 0x75, 0x76, 0xee, 0x5b, 0x3f, 0xcf, 0x7d, 0xeb, 0xeb, 0x85, 0xbf, 0x72,
-	0x76, 0xe1, 0xaf, 0xfc, 0xb8, 0xf0, 0x57, 0xa6, 0x2e, 0x7d, 0xf2, 0xe4, 0x77, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x2b, 0x51, 0xd4, 0x7a, 0xf9, 0x05, 0x00, 0x00,
+	// 640 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0xcf, 0x6e, 0xd3, 0x4e,
+	0x10, 0xfe, 0xd9, 0xa9, 0x9d, 0x66, 0x5a, 0xf5, 0x17, 0x96, 0x0a, 0x59, 0x15, 0x8a, 0x22, 0x83,
+	0x68, 0x10, 0x50, 0x68, 0x38, 0x70, 0x43, 0xfc, 0x29, 0x95, 0x2a, 0x01, 0x8d, 0x56, 0x70, 0xe0,
+	0xb8, 0xb1, 0xd7, 0x8e, 0x8b, 0xed, 0x35, 0xf6, 0x44, 0x25, 0x6f, 0xc2, 0x23, 0x71, 0xe0, 0xc0,
+	0x23, 0xa0, 0x22, 0xde, 0x03, 0xed, 0x78, 0x5d, 0xbb, 0x52, 0x38, 0x71, 0xe5, 0x94, 0xfd, 0x66,
+	0x3e, 0xef, 0x37, 0xdf, 0xcc, 0x4e, 0x60, 0x50, 0x85, 0x1f, 0x0f, 0x8a, 0x52, 0xa1, 0x62, 0x9b,
+	0xf4, 0x93, 0x55, 0xf1, 0x1e, 0xcc, 0x45, 0x25, 0xeb, 0xa8, 0x7f, 0x0e, 0xce, 0x49, 0x26, 0x62,
+	0xc9, 0x76, 0xc1, 0x39, 0x4f, 0x42, 0x5c, 0x78, 0xd6, 0xd8, 0x9a, 0x38, 0xbc, 0x06, 0xec, 0x06,
+	0xb8, 0x0b, 0x99, 0xc4, 0x0b, 0xf4, 0x6c, 0x0a, 0x1b, 0xc4, 0x18, 0x6c, 0x84, 0x02, 0x85, 0xd7,
+	0x1b, 0x5b, 0x93, 0x6d, 0x4e, 0x67, 0x76, 0x13, 0x06, 0x98, 0x64, 0xb2, 0x42, 0x91, 0x15, 0xde,
+	0xc6, 0xd8, 0x9a, 0x0c, 0x78, 0x1b, 0x60, 0x3b, 0x60, 0x27, 0xa1, 0xe7, 0x8c, 0xad, 0x49, 0x8f,
+	0xdb, 0x49, 0xe8, 0xc7, 0x30, 0x38, 0x16, 0x81, 0x7c, 0x9e, 0xc7, 0xa9, 0x64, 0x43, 0xe8, 0xad,
+	0xc4, 0xb9, 0x91, 0xd6, 0x47, 0x5d, 0x4e, 0x91, 0x60, 0xb0, 0x30, 0xba, 0x35, 0xd0, 0xb2, 0xa5,
+	0x4a, 0x53, 0x92, 0x75, 0x38, 0x9d, 0xd9, 0x08, 0x20, 0x50, 0x79, 0x94, 0x84, 0x32, 0x0f, 0x24,
+	0xe9, 0xda, 0xbc, 0x13, 0xf1, 0x3f, 0x03, 0xbc, 0x5b, 0x44, 0xc8, 0x65, 0xb5, 0x4c, 0x51, 0x1b,
+	0x8a, 0x65, 0x1e, 0xca, 0xd2, 0x88, 0x19, 0xa4, 0x2b, 0x10, 0xb1, 0x34, 0x6a, 0xfa, 0x48, 0x5a,
+	0x22, 0x90, 0x97, 0x5a, 0x22, 0x90, 0xfa, 0xeb, 0xb9, 0x14, 0x4b, 0x5c, 0x91, 0x8e, 0xc3, 0x0d,
+	0xd2, 0xd5, 0x56, 0x59, 0x92, 0x4a, 0xf2, 0xe7, 0xf0, 0x1a, 0xf8, 0xdf, 0x6c, 0xe8, 0x6b, 0x8f,
+	0x33, 0x55, 0xb1, 0x3b, 0xe0, 0x96, 0x81, 0x06, 0xa4, 0xbb, 0x35, 0xdd, 0x39, 0x68, 0xc6, 0x71,
+	0xc0, 0x65, 0x80, 0xdc, 0x64, 0xd9, 0x03, 0x18, 0x14, 0xf8, 0x5a, 0x46, 0xf8, 0x6a, 0x55, 0x57,
+	0xb3, 0x35, 0xfd, 0xbf, 0xa5, 0xce, 0x54, 0x92, 0x23, 0x6f, 0x19, 0xec, 0x21, 0x40, 0x81, 0x5c,
+	0x8f, 0x44, 0xf3, 0x7b, 0xeb, 0xf9, 0x1d, 0x0a, 0xbb, 0x0b, 0xfd, 0x02, 0xdf, 0xa8, 0x25, 0x2e,
+	0xc8, 0xc2, 0x1a, 0x76, 0x93, 0x67, 0xfb, 0xe0, 0x16, 0xf8, 0x56, 0x55, 0xb5, 0xab, 0x35, 0x4c,
+	0x93, 0x66, 0xf7, 0xc0, 0x8d, 0x68, 0x8e, 0x9e, 0x4b, 0xc4, 0xeb, 0x2d, 0xf1, 0x72, 0xc4, 0xdc,
+	0x50, 0x98, 0x07, 0xfd, 0x4f, 0x4b, 0x91, 0x26, 0xb8, 0xf2, 0xfa, 0xd4, 0xac, 0x06, 0xea, 0x41,
+	0x46, 0x22, 0x48, 0x44, 0x7a, 0xa4, 0x5f, 0xd6, 0x26, 0xbd, 0xac, 0x4e, 0xc4, 0xff, 0x65, 0xc3,
+	0xa6, 0xbe, 0xef, 0x24, 0x8f, 0xd4, 0xbf, 0x7e, 0xfe, 0x75, 0x3f, 0xf5, 0x63, 0x8e, 0x74, 0x3b,
+	0x8f, 0xbc, 0x01, 0x6d, 0xa5, 0x41, 0xfe, 0x7b, 0xe8, 0x9f, 0xce, 0xcf, 0xa8, 0xcb, 0xb7, 0xc1,
+	0x29, 0x83, 0xd3, 0xf9, 0xd9, 0x1f, 0x9a, 0x5c, 0x27, 0xf5, 0xee, 0xe0, 0xaa, 0x68, 0x76, 0x07,
+	0x57, 0x85, 0xde, 0x9d, 0xa2, 0x54, 0x73, 0x6a, 0xa0, 0xcd, 0xe9, 0xec, 0x4b, 0x18, 0xd6, 0x3b,
+	0xa8, 0x3d, 0x1c, 0x49, 0x94, 0x01, 0xb2, 0x5b, 0xd0, 0x2b, 0x54, 0x65, 0x6e, 0xbf, 0x76, 0xd5,
+	0xe6, 0x4c, 0x55, 0x5c, 0x67, 0xd9, 0x7d, 0x70, 0x4b, 0xfa, 0xd0, 0xcc, 0x6f, 0xb7, 0xe5, 0xb5,
+	0x8b, 0xcd, 0x0d, 0xc7, 0x7f, 0x06, 0xdb, 0x33, 0x51, 0x8a, 0xac, 0x59, 0xbc, 0x47, 0xe0, 0x68,
+	0x5f, 0x5a, 0xa4, 0x37, 0xd9, 0x9a, 0xee, 0x75, 0x2d, 0x5c, 0xad, 0x86, 0xd7, 0x44, 0x7f, 0x02,
+	0xc3, 0xcb, 0x1b, 0x8e, 0xa5, 0xc0, 0x65, 0x49, 0xff, 0x8e, 0x91, 0x14, 0x58, 0xdf, 0xb2, 0xcd,
+	0x6b, 0xe0, 0x3f, 0xed, 0x30, 0x5f, 0xaa, 0xac, 0x10, 0x2d, 0xf3, 0x90, 0x4c, 0x19, 0xe6, 0x61,
+	0x13, 0x9d, 0x92, 0x05, 0x13, 0x9d, 0xfa, 0x4f, 0x4c, 0xad, 0x1f, 0x54, 0xaa, 0x74, 0x23, 0xf7,
+	0xc1, 0x49, 0xf2, 0x48, 0x35, 0xb5, 0x76, 0x1a, 0x62, 0x06, 0xc2, 0xeb, 0xfc, 0x8b, 0xe1, 0xd7,
+	0x8b, 0x91, 0xf5, 0xfd, 0x62, 0x64, 0xfd, 0xb8, 0x18, 0x59, 0x5f, 0x7e, 0x8e, 0xfe, 0x9b, 0xbb,
+	0x44, 0x7d, 0xfc, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x99, 0xb3, 0x14, 0x59, 0xf1, 0x05, 0x00, 0x00,
 }
 
 func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -853,6 +885,9 @@
 		i++
 		i = encodeVarintSdk(dAtA, i, uint64(m.Id))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -891,6 +926,9 @@
 		i++
 		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
 		i += 4
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -934,6 +972,9 @@
 		dAtA[i] = 0x28
 		i++
 		i = encodeVarintSdk(dAtA, i, uint64(m.Smile))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -1023,6 +1064,9 @@
 		i++
 		i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
 		i += copy(dAtA[i:], m.FacialData)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -1118,6 +1162,9 @@
 		i++
 		i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1157,6 +1204,9 @@
 		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
 		i += 4
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1195,6 +1245,9 @@
 		}
 		i += n15
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1225,6 +1278,9 @@
 			i += n
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1250,6 +1306,9 @@
 			i = encodeVarintSdk(dAtA, i, uint64(len(b)))
 			i += copy(dAtA[i:], b)
 		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -1281,6 +1340,9 @@
 		i = encodeVarintSdk(dAtA, i, uint64(len(m.Feat2)))
 		i += copy(dAtA[i:], m.Feat2)
 	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
 	return i, nil
 }
 
@@ -1310,6 +1372,9 @@
 			}
 			i += n
 		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
 	return i, nil
 }
@@ -1346,6 +1411,9 @@
 	if m.Id != 0 {
 		n += 1 + sovSdk(uint64(m.Id))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -1366,6 +1434,9 @@
 	}
 	if m.Confidence != 0 {
 		n += 5
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
 	}
 	return n
 }
@@ -1390,6 +1461,9 @@
 	}
 	if m.Smile != 0 {
 		n += 1 + sovSdk(uint64(m.Smile))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
 	}
 	return n
 }
@@ -1430,6 +1504,9 @@
 	l = len(m.FacialData)
 	if l > 0 {
 		n += 1 + l + sovSdk(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
 	}
 	return n
 }
@@ -1474,6 +1551,9 @@
 	if m.FaceID != 0 {
 		n += 1 + sovSdk(uint64(m.FaceID))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -1493,6 +1573,9 @@
 	if m.Prob != 0 {
 		n += 5
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -1510,6 +1593,9 @@
 		l = m.Result.Size()
 		n += 1 + l + sovSdk(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -1525,6 +1611,9 @@
 			n += 1 + l + sovSdk(uint64(l))
 		}
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -1539,6 +1628,9 @@
 			l = len(b)
 			n += 1 + l + sovSdk(uint64(l))
 		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
 	}
 	return n
 }
@@ -1557,6 +1649,9 @@
 	if l > 0 {
 		n += 1 + l + sovSdk(uint64(l))
 	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
 	return n
 }
 
@@ -1571,6 +1666,9 @@
 			l = e.Size()
 			n += 1 + l + sovSdk(uint64(l))
 		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
 	}
 	return n
 }
@@ -1755,6 +1853,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -1876,6 +1975,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2024,6 +2124,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2346,6 +2447,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2687,6 +2789,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2806,6 +2909,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2931,6 +3035,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3018,6 +3123,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3103,6 +3209,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3224,6 +3331,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3311,6 +3419,7 @@
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
diff --git a/sdk.proto b/sdk.proto
index 3a8b26d..811c931 100644
--- a/sdk.proto
+++ b/sdk.proto
@@ -73,4 +73,4 @@
 // sdk yolo detect
 message ParamYoloObj{
     repeated ObjInfo infos = 1;
-}
\ No newline at end of file
+}
diff --git a/sysset.pb.go b/sysset.pb.go
index 72a5a57..a3a6ef6 100644
--- a/sysset.pb.go
+++ b/sysset.pb.go
@@ -1,4 +1,4 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: sysset.proto
 
 package protomsg
@@ -6,6 +6,7 @@
 import (
 	fmt "fmt"
 	proto "github.com/golang/protobuf/proto"
+	io "io"
 	math "math"
 )
 
@@ -18,7 +19,7 @@
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type LocalConfig struct {
 	ServerId             string   `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
@@ -48,18 +49,26 @@
 func (*LocalConfig) Descriptor() ([]byte, []int) {
 	return fileDescriptor_5be590c6b2a0d755, []int{0}
 }
-
 func (m *LocalConfig) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_LocalConfig.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *LocalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_LocalConfig.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_LocalConfig.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 *LocalConfig) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LocalConfig.Merge(m, src)
 }
 func (m *LocalConfig) XXX_Size() int {
-	return xxx_messageInfo_LocalConfig.Size(m)
+	return m.Size()
 }
 func (m *LocalConfig) XXX_DiscardUnknown() {
 	xxx_messageInfo_LocalConfig.DiscardUnknown(m)
@@ -195,18 +204,26 @@
 func (*PollConfig) Descriptor() ([]byte, []int) {
 	return fileDescriptor_5be590c6b2a0d755, []int{1}
 }
-
 func (m *PollConfig) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PollConfig.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PollConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PollConfig.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PollConfig.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 *PollConfig) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PollConfig.Merge(m, src)
 }
 func (m *PollConfig) XXX_Size() int {
-	return xxx_messageInfo_PollConfig.Size(m)
+	return m.Size()
 }
 func (m *PollConfig) XXX_DiscardUnknown() {
 	xxx_messageInfo_PollConfig.DiscardUnknown(m)
@@ -259,18 +276,26 @@
 func (*Cluster) Descriptor() ([]byte, []int) {
 	return fileDescriptor_5be590c6b2a0d755, []int{2}
 }
-
 func (m *Cluster) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Cluster.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Cluster.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 *Cluster) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Cluster.Merge(m, src)
 }
 func (m *Cluster) XXX_Size() int {
-	return xxx_messageInfo_Cluster.Size(m)
+	return m.Size()
 }
 func (m *Cluster) XXX_DiscardUnknown() {
 	xxx_messageInfo_Cluster.DiscardUnknown(m)
@@ -332,18 +357,26 @@
 func (*ClusterNode) Descriptor() ([]byte, []int) {
 	return fileDescriptor_5be590c6b2a0d755, []int{3}
 }
-
 func (m *ClusterNode) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ClusterNode.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *ClusterNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ClusterNode.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_ClusterNode.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 *ClusterNode) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_ClusterNode.Merge(m, src)
 }
 func (m *ClusterNode) XXX_Size() int {
-	return xxx_messageInfo_ClusterNode.Size(m)
+	return m.Size()
 }
 func (m *ClusterNode) XXX_DiscardUnknown() {
 	xxx_messageInfo_ClusterNode.DiscardUnknown(m)
@@ -410,39 +443,1733 @@
 func init() { proto.RegisterFile("sysset.proto", fileDescriptor_5be590c6b2a0d755) }
 
 var fileDescriptor_5be590c6b2a0d755 = []byte{
-	// 531 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcd, 0x8e, 0xda, 0x3e,
-	0x10, 0x17, 0x2c, 0x81, 0x64, 0xc2, 0x9f, 0xff, 0xca, 0xea, 0x87, 0x4b, 0xbf, 0x28, 0x27, 0xa4,
-	0x4a, 0x1c, 0xda, 0x47, 0xd8, 0x5e, 0x22, 0x95, 0x15, 0x42, 0x2b, 0xf5, 0x18, 0x99, 0x78, 0x8a,
-	0xac, 0x4d, 0x62, 0xcb, 0x36, 0x0b, 0xb9, 0xf5, 0x9d, 0xfa, 0x1c, 0x7d, 0xa7, 0xca, 0x76, 0x02,
-	0xec, 0x56, 0xaa, 0x7a, 0x4a, 0xe6, 0xf7, 0x31, 0x33, 0xb6, 0x67, 0x60, 0x6c, 0x1a, 0x63, 0xd0,
-	0x2e, 0x95, 0x96, 0x56, 0x92, 0xd8, 0x7f, 0x2a, 0xb3, 0x9b, 0xff, 0x18, 0x40, 0xfa, 0x55, 0x16,
-	0xac, 0xbc, 0x91, 0xf5, 0x77, 0xb1, 0x23, 0xaf, 0x21, 0x31, 0xa8, 0x1f, 0x50, 0xe7, 0x82, 0xd3,
-	0xde, 0xac, 0xb7, 0x48, 0x36, 0x71, 0x00, 0x32, 0x4e, 0xde, 0x43, 0xda, 0x92, 0x35, 0xab, 0x90,
-	0xf6, 0x3d, 0x0d, 0x01, 0xba, 0x65, 0x15, 0x5e, 0x08, 0x6c, 0xa3, 0x90, 0x5e, 0xcd, 0x7a, 0x8b,
-	0xa8, 0x13, 0xdc, 0x35, 0x0a, 0x2f, 0xd3, 0x2b, 0x3a, 0x78, 0x94, 0x5e, 0x91, 0x57, 0x10, 0xb3,
-	0x92, 0xe9, 0xca, 0x71, 0x91, 0xe7, 0x46, 0x3e, 0xce, 0x14, 0x79, 0x0b, 0x10, 0x28, 0x25, 0xb5,
-	0xa5, 0x43, 0x9f, 0x37, 0xf1, 0xc8, 0x5a, 0x6a, 0x4b, 0xde, 0x00, 0x1c, 0x70, 0x9b, 0x2b, 0x51,
-	0x38, 0xef, 0x28, 0xe4, 0x3d, 0xe0, 0x76, 0x2d, 0x8a, 0x4c, 0x91, 0x19, 0x8c, 0x3b, 0xd6, 0xdb,
-	0xe3, 0xd0, 0x56, 0xe0, 0xbd, 0x7f, 0x0a, 0x09, 0x9a, 0xce, 0x9e, 0x84, 0xd2, 0x68, 0x82, 0xfb,
-	0x1d, 0xa4, 0x2d, 0xe7, 0xcd, 0x10, 0x6a, 0x7b, 0xd6, 0x7b, 0x17, 0x70, 0x5d, 0xec, 0x6d, 0x5e,
-	0xb1, 0x63, 0xce, 0xf7, 0x9a, 0x59, 0x21, 0x6b, 0x9a, 0x7a, 0xd1, 0xa4, 0xd8, 0xdb, 0x15, 0x3b,
-	0x7e, 0x69, 0xd1, 0x93, 0x52, 0xd4, 0x67, 0xe5, 0xf8, 0xac, 0x14, 0xf5, 0x49, 0x39, 0x85, 0x58,
-	0xa3, 0xbf, 0x17, 0x4e, 0xff, 0x0b, 0xa7, 0xe9, 0x62, 0x77, 0x4b, 0x3b, 0x66, 0x31, 0x3f, 0xb0,
-	0x86, 0x4e, 0x42, 0xab, 0x2e, 0xfe, 0xc6, 0x1a, 0x47, 0xd5, 0xe8, 0x5a, 0x31, 0xf7, 0xf4, 0xff,
-	0x40, 0xd5, 0x68, 0x57, 0xcc, 0xdc, 0x3b, 0x4a, 0x23, 0x2b, 0x5d, 0x9b, 0xf4, 0xda, 0xd7, 0x1c,
-	0xb9, 0x78, 0xc5, 0x8e, 0xf3, 0x23, 0xc0, 0x5a, 0x96, 0xff, 0x3a, 0x00, 0x4a, 0x96, 0x65, 0xae,
-	0x50, 0x0b, 0xc9, 0xfd, 0x00, 0x44, 0x1b, 0x70, 0xd0, 0xda, 0x23, 0xe4, 0x19, 0x44, 0x1c, 0x4b,
-	0xd6, 0xb4, 0x4f, 0x1f, 0x02, 0xf2, 0x02, 0x86, 0x58, 0xb3, 0x6d, 0x89, 0xfe, 0xc9, 0xe3, 0x4d,
-	0x1b, 0xcd, 0x7f, 0xf6, 0x60, 0x74, 0x53, 0xee, 0x8d, 0x45, 0xed, 0x5e, 0xb8, 0x08, 0xbf, 0xe7,
-	0xc2, 0x49, 0x8b, 0x64, 0x9c, 0x7c, 0x80, 0x71, 0x47, 0x5f, 0xcc, 0x5e, 0xda, 0x62, 0x7e, 0xf8,
-	0xa6, 0x10, 0x2b, 0x66, 0xcc, 0x41, 0x6a, 0xee, 0xcb, 0x27, 0x9b, 0x53, 0xec, 0xb2, 0x3f, 0x08,
-	0x6d, 0xf7, 0xac, 0x3c, 0x0f, 0x5e, 0xd2, 0x22, 0x99, 0x22, 0x1f, 0x21, 0xaa, 0x25, 0x47, 0x43,
-	0xa3, 0xd9, 0xd5, 0x22, 0xfd, 0xf4, 0x7c, 0xd9, 0xed, 0xc7, 0xb2, 0x6d, 0xef, 0x56, 0x72, 0xdc,
-	0x04, 0xcd, 0xfc, 0x57, 0x0f, 0xd2, 0x0b, 0x98, 0x4c, 0xa0, 0x7f, 0xea, 0xb8, 0x2f, 0xf8, 0x93,
-	0x93, 0xf4, 0x9f, 0x9e, 0xe4, 0xd1, 0x05, 0x5f, 0xfd, 0x7d, 0xc3, 0x06, 0x7f, 0x6c, 0xd8, 0x4b,
-	0x18, 0xb9, 0x2e, 0x9c, 0x37, 0xac, 0xc8, 0xd0, 0x85, 0x19, 0x3f, 0x13, 0xca, 0xaf, 0x47, 0x47,
-	0x28, 0x97, 0xb2, 0xd0, 0xe8, 0x26, 0xc6, 0x8a, 0x0a, 0xdb, 0xe5, 0x80, 0x00, 0xdd, 0x89, 0x0a,
-	0xb7, 0x43, 0x7f, 0xd8, 0xcf, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x2b, 0xd8, 0x92, 0x94, 0x23,
-	0x04, 0x00, 0x00,
+	// 559 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcd, 0x8e, 0xd3, 0x3e,
+	0x10, 0xff, 0xa7, 0xbb, 0x69, 0x93, 0x49, 0xff, 0xcb, 0xca, 0xe2, 0x23, 0x2c, 0x50, 0x4a, 0x4f,
+	0x95, 0x90, 0xf6, 0x00, 0x6f, 0xc0, 0x72, 0x89, 0xc4, 0xae, 0xaa, 0x6a, 0x25, 0x8e, 0x91, 0x1b,
+	0x0f, 0x95, 0xb5, 0x49, 0x6c, 0xd9, 0xee, 0xb6, 0xb9, 0xf1, 0x18, 0xbc, 0x07, 0x2f, 0xc1, 0x05,
+	0x89, 0x47, 0x40, 0xe5, 0x45, 0x90, 0xed, 0xa4, 0xed, 0x2e, 0x12, 0xe2, 0x94, 0xcc, 0xef, 0x63,
+	0x66, 0x6c, 0xcf, 0xc0, 0x50, 0x37, 0x5a, 0xa3, 0x39, 0x97, 0x4a, 0x18, 0x41, 0x22, 0xf7, 0xa9,
+	0xf4, 0x72, 0xf2, 0xf9, 0x18, 0x92, 0x0f, 0xa2, 0xa0, 0xe5, 0x85, 0xa8, 0x3f, 0xf1, 0x25, 0x79,
+	0x06, 0xb1, 0x46, 0x75, 0x8b, 0x2a, 0xe7, 0x2c, 0x0d, 0xc6, 0xc1, 0x34, 0x9e, 0x47, 0x1e, 0xc8,
+	0x18, 0x79, 0x09, 0x49, 0x4b, 0xd6, 0xb4, 0xc2, 0xb4, 0xe7, 0x68, 0xf0, 0xd0, 0x15, 0xad, 0xf0,
+	0x40, 0x60, 0x1a, 0x89, 0xe9, 0xd1, 0x38, 0x98, 0x86, 0x9d, 0xe0, 0xba, 0x91, 0x78, 0x98, 0x5e,
+	0xa6, 0xc7, 0x77, 0xd2, 0x4b, 0xf2, 0x14, 0x22, 0x5a, 0x52, 0x55, 0x59, 0x2e, 0x74, 0xdc, 0xc0,
+	0xc5, 0x99, 0x24, 0x2f, 0x00, 0x3c, 0x25, 0x85, 0x32, 0x69, 0xdf, 0xe5, 0x8d, 0x1d, 0x32, 0x13,
+	0xca, 0x90, 0xe7, 0x00, 0x6b, 0x5c, 0xe4, 0x92, 0x17, 0xd6, 0x3b, 0xf0, 0x79, 0xd7, 0xb8, 0x98,
+	0xf1, 0x22, 0x93, 0x64, 0x0c, 0xc3, 0x8e, 0x75, 0xf6, 0xc8, 0xb7, 0xe5, 0x79, 0xe7, 0x3f, 0x83,
+	0x18, 0x75, 0x67, 0x8f, 0x7d, 0x69, 0xd4, 0xde, 0x3d, 0x82, 0xa4, 0xe5, 0x9c, 0x19, 0x7c, 0x6d,
+	0xc7, 0x3a, 0xef, 0x14, 0x4e, 0x8b, 0x95, 0xc9, 0x2b, 0xba, 0xc9, 0xd9, 0x4a, 0x51, 0xc3, 0x45,
+	0x9d, 0x26, 0x4e, 0x74, 0x52, 0xac, 0xcc, 0x25, 0xdd, 0xbc, 0x6f, 0xd1, 0x9d, 0x92, 0xd7, 0x7b,
+	0xe5, 0x70, 0xaf, 0xe4, 0xf5, 0x4e, 0x79, 0x06, 0x91, 0x42, 0x77, 0x2f, 0x2c, 0xfd, 0xdf, 0x9f,
+	0xa6, 0x8b, 0xed, 0x2d, 0x2d, 0xa9, 0xc1, 0x7c, 0x4d, 0x9b, 0xf4, 0xc4, 0xb7, 0x6a, 0xe3, 0x8f,
+	0xb4, 0xb1, 0x54, 0x8d, 0xb6, 0x15, 0x7d, 0x93, 0x3e, 0xf0, 0x54, 0x8d, 0xe6, 0x92, 0xea, 0x1b,
+	0x4b, 0x29, 0xa4, 0xa5, 0x6d, 0x33, 0x3d, 0x75, 0x35, 0x07, 0x36, 0xbe, 0xa4, 0x9b, 0xc9, 0x06,
+	0x60, 0x26, 0xca, 0x7f, 0x1d, 0x00, 0x29, 0xca, 0x32, 0x97, 0xa8, 0xb8, 0x60, 0x6e, 0x00, 0xc2,
+	0x39, 0x58, 0x68, 0xe6, 0x10, 0xf2, 0x10, 0x42, 0x86, 0x25, 0x6d, 0xda, 0xa7, 0xf7, 0x01, 0x79,
+	0x0c, 0x7d, 0xac, 0xe9, 0xa2, 0x44, 0xf7, 0xe4, 0xd1, 0xbc, 0x8d, 0x26, 0x5f, 0x03, 0x18, 0x5c,
+	0x94, 0x2b, 0x6d, 0x50, 0xd9, 0x17, 0x2e, 0xfc, 0xef, 0xbe, 0x70, 0xdc, 0x22, 0x19, 0x23, 0xaf,
+	0x60, 0xd8, 0xd1, 0x07, 0xb3, 0x97, 0xb4, 0x98, 0x1b, 0xbe, 0x33, 0x88, 0x24, 0xd5, 0x7a, 0x2d,
+	0x14, 0x73, 0xe5, 0xe3, 0xf9, 0x2e, 0xb6, 0xd9, 0x6f, 0xb9, 0x32, 0x2b, 0x5a, 0xee, 0x07, 0x2f,
+	0x6e, 0x91, 0x4c, 0x92, 0xd7, 0x10, 0xd6, 0x82, 0xa1, 0x4e, 0xc3, 0xf1, 0xd1, 0x34, 0x79, 0xf3,
+	0xe8, 0xbc, 0xdb, 0x8f, 0xf3, 0xb6, 0xbd, 0x2b, 0xc1, 0x70, 0xee, 0x35, 0x93, 0xef, 0x01, 0x24,
+	0x07, 0x30, 0x39, 0x81, 0xde, 0xae, 0xe3, 0x1e, 0x67, 0xf7, 0x4e, 0xd2, 0xbb, 0x7f, 0x92, 0x3b,
+	0x17, 0x7c, 0xf4, 0xf7, 0x0d, 0x3b, 0xfe, 0x63, 0xc3, 0x9e, 0xc0, 0xc0, 0x76, 0x61, 0xbd, 0x7e,
+	0x45, 0xfa, 0x36, 0xcc, 0xd8, 0x9e, 0x90, 0x6e, 0x3d, 0x3a, 0x42, 0xda, 0x94, 0x85, 0x42, 0x3b,
+	0x31, 0x86, 0x57, 0xd8, 0x2e, 0x07, 0x78, 0xe8, 0x9a, 0x57, 0xf8, 0xee, 0xf4, 0xdb, 0x76, 0x14,
+	0xfc, 0xd8, 0x8e, 0x82, 0x9f, 0xdb, 0x51, 0xf0, 0xe5, 0xd7, 0xe8, 0xbf, 0x45, 0xdf, 0x1d, 0xff,
+	0xed, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x6d, 0x48, 0x9b, 0x35, 0x04, 0x00, 0x00,
 }
+
+func (m *LocalConfig) 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 *LocalConfig) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ServerId) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
+		i += copy(dAtA[i:], m.ServerId)
+	}
+	if len(m.ServerName) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
+		i += copy(dAtA[i:], m.ServerName)
+	}
+	if m.ServerType != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.ServerType))
+	}
+	if len(m.ServerIp) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
+		i += copy(dAtA[i:], m.ServerIp)
+	}
+	if len(m.AlarmIp) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.AlarmIp)))
+		i += copy(dAtA[i:], m.AlarmIp)
+	}
+	if m.AlarmPort != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.AlarmPort))
+	}
+	if len(m.WebPicIp) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.WebPicIp)))
+		i += copy(dAtA[i:], m.WebPicIp)
+	}
+	if m.WebPicPort != 0 {
+		dAtA[i] = 0x40
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.WebPicPort))
+	}
+	if len(m.EsPicIp) > 0 {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.EsPicIp)))
+		i += copy(dAtA[i:], m.EsPicIp)
+	}
+	if m.EsPicPort != 0 {
+		dAtA[i] = 0x50
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.EsPicPort))
+	}
+	if m.CutMaxDuration != 0 {
+		dAtA[i] = 0x58
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.CutMaxDuration))
+	}
+	if m.CutMinDuration != 0 {
+		dAtA[i] = 0x60
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.CutMinDuration))
+	}
+	if len(m.Reserved) > 0 {
+		dAtA[i] = 0x6a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.Reserved)))
+		i += copy(dAtA[i:], m.Reserved)
+	}
+	if len(m.GateWay) > 0 {
+		dAtA[i] = 0x72
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.GateWay)))
+		i += copy(dAtA[i:], m.GateWay)
+	}
+	if len(m.NetMask) > 0 {
+		dAtA[i] = 0x7a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.NetMask)))
+		i += copy(dAtA[i:], m.NetMask)
+	}
+	if m.RealMax != 0 {
+		dAtA[i] = 0x80
+		i++
+		dAtA[i] = 0x1
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.RealMax))
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *PollConfig) 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 *PollConfig) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ServerId) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
+		i += copy(dAtA[i:], m.ServerId)
+	}
+	if m.PollPeriod != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.PollPeriod))
+	}
+	if m.Delay != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(m.Delay))
+	}
+	if m.Enable {
+		dAtA[i] = 0x20
+		i++
+		if m.Enable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Cluster) 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 *Cluster) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ClusterId) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
+		i += copy(dAtA[i:], m.ClusterId)
+	}
+	if len(m.ClusterName) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterName)))
+		i += copy(dAtA[i:], m.ClusterName)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	if len(m.VirtualIp) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.VirtualIp)))
+		i += copy(dAtA[i:], m.VirtualIp)
+	}
+	if len(m.Nodes) > 0 {
+		for _, msg := range m.Nodes {
+			dAtA[i] = 0x2a
+			i++
+			i = encodeVarintSysset(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *ClusterNode) 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 *ClusterNode) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Id) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
+		i += copy(dAtA[i:], m.Id)
+	}
+	if len(m.ClusterId) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
+		i += copy(dAtA[i:], m.ClusterId)
+	}
+	if len(m.ServerId) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
+		i += copy(dAtA[i:], m.ServerId)
+	}
+	if len(m.ServerName) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
+		i += copy(dAtA[i:], m.ServerName)
+	}
+	if len(m.NodeId) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeId)))
+		i += copy(dAtA[i:], m.NodeId)
+	}
+	if len(m.NodeIp) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeIp)))
+		i += copy(dAtA[i:], m.NodeIp)
+	}
+	if len(m.CreateTime) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintSysset(dAtA, i, uint64(len(m.CreateTime)))
+		i += copy(dAtA[i:], m.CreateTime)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *LocalConfig) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ServerId)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.ServerName)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.ServerType != 0 {
+		n += 1 + sovSysset(uint64(m.ServerType))
+	}
+	l = len(m.ServerIp)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.AlarmIp)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.AlarmPort != 0 {
+		n += 1 + sovSysset(uint64(m.AlarmPort))
+	}
+	l = len(m.WebPicIp)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.WebPicPort != 0 {
+		n += 1 + sovSysset(uint64(m.WebPicPort))
+	}
+	l = len(m.EsPicIp)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.EsPicPort != 0 {
+		n += 1 + sovSysset(uint64(m.EsPicPort))
+	}
+	if m.CutMaxDuration != 0 {
+		n += 1 + sovSysset(uint64(m.CutMaxDuration))
+	}
+	if m.CutMinDuration != 0 {
+		n += 1 + sovSysset(uint64(m.CutMinDuration))
+	}
+	l = len(m.Reserved)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.GateWay)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.NetMask)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.RealMax != 0 {
+		n += 2 + sovSysset(uint64(m.RealMax))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *PollConfig) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ServerId)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.PollPeriod != 0 {
+		n += 1 + sovSysset(uint64(m.PollPeriod))
+	}
+	if m.Delay != 0 {
+		n += 1 + sovSysset(uint64(m.Delay))
+	}
+	if m.Enable {
+		n += 2
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Cluster) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ClusterId)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.ClusterName)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.VirtualIp)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if len(m.Nodes) > 0 {
+		for _, e := range m.Nodes {
+			l = e.Size()
+			n += 1 + l + sovSysset(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *ClusterNode) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Id)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.ClusterId)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.ServerId)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.ServerName)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.NodeId)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.NodeIp)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	l = len(m.CreateTime)
+	if l > 0 {
+		n += 1 + l + sovSysset(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func sovSysset(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozSysset(x uint64) (n int) {
+	return sovSysset(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *LocalConfig) 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 ErrIntOverflowSysset
+			}
+			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: LocalConfig: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LocalConfig: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServerId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServerName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerType", wireType)
+			}
+			m.ServerType = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ServerType |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerIp", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServerIp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AlarmIp", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.AlarmIp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AlarmPort", wireType)
+			}
+			m.AlarmPort = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.AlarmPort |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WebPicIp", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.WebPicIp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WebPicPort", wireType)
+			}
+			m.WebPicPort = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.WebPicPort |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EsPicIp", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.EsPicIp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EsPicPort", wireType)
+			}
+			m.EsPicPort = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EsPicPort |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CutMaxDuration", wireType)
+			}
+			m.CutMaxDuration = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CutMaxDuration |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CutMinDuration", wireType)
+			}
+			m.CutMinDuration = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CutMinDuration |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 13:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Reserved = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 14:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GateWay", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.GateWay = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 15:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NetMask", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.NetMask = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 16:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RealMax", wireType)
+			}
+			m.RealMax = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RealMax |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSysset(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PollConfig) 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 ErrIntOverflowSysset
+			}
+			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: PollConfig: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PollConfig: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServerId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PollPeriod", wireType)
+			}
+			m.PollPeriod = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PollPeriod |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Delay", wireType)
+			}
+			m.Delay = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Delay |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Enable = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSysset(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Cluster) 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 ErrIntOverflowSysset
+			}
+			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: Cluster: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Cluster: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ClusterId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ClusterName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VirtualIp", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.VirtualIp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Nodes = append(m.Nodes, &ClusterNode{})
+			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSysset(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ClusterNode) 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 ErrIntOverflowSysset
+			}
+			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: ClusterNode: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ClusterNode: 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 ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			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 ClusterId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ClusterId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServerId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServerName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServerName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.NodeId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodeIp", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.NodeIp = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSysset
+				}
+				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 ErrInvalidLengthSysset
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.CreateTime = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSysset(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthSysset
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipSysset(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowSysset
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowSysset
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthSysset
+			}
+			iNdEx += length
+			if iNdEx < 0 {
+				return 0, ErrInvalidLengthSysset
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowSysset
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipSysset(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+				if iNdEx < 0 {
+					return 0, ErrInvalidLengthSysset
+				}
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthSysset = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowSysset   = fmt.Errorf("proto: integer overflow")
+)

--
Gitblit v1.8.0