repo_description: Distributed reliable key-value store for the most critical data of a distributed system
repo_topics: cncf consensus database distributed-database distributed-systems etcd go key-value kubernetes raft
code: // Code generated by protoc-gen-gogo. DO NOT EDIT.
  // source: rpc.proto
  
  package etcdserverpb
  
  import (
  	fmt "fmt"
  	io "io"
  	math "math"
  	math_bits "math/bits"
  
  	proto "github.com/golang/protobuf/proto"
  	_ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options"
  	authpb "go.etcd.io/etcd/api/v3/authpb"
  	mvccpb "go.etcd.io/etcd/api/v3/mvccpb"
  	_ "go.etcd.io/etcd/api/v3/versionpb"
  	_ "google.golang.org/genproto/googleapis/api/annotations"
  )
  
  // 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.ProtoPackageIsVersion3 // please upgrade the proto package
  
  type AlarmType int32
  
  const (
  	AlarmType_NONE    AlarmType = 0
  	AlarmType_NOSPACE AlarmType = 1
  	AlarmType_CORRUPT AlarmType = 2
  )
  
  var AlarmType_name = map[int32]string{
  	0: "NONE",
  	1: "NOSPACE",
  	2: "CORRUPT",
  }
  
  var AlarmType_value = map[string]int32{
  	"NONE":    0,
  	"NOSPACE": 1,
  	"CORRUPT": 2,
  }
  
  func (x AlarmType) String() string {
  	return proto.EnumName(AlarmType_name, int32(x))
  }
  
  func (AlarmType) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{0}
  }
  
  type RangeRequest_SortOrder int32
  
  const (
  	RangeRequest_NONE    RangeRequest_SortOrder = 0
  	RangeRequest_ASCEND  RangeRequest_SortOrder = 1
  	RangeRequest_DESCEND RangeRequest_SortOrder = 2
  )
  
  var RangeRequest_SortOrder_name = map[int32]string{
  	0: "NONE",
  	1: "ASCEND",
  	2: "DESCEND",
  }
  
  var RangeRequest_SortOrder_value = map[string]int32{
  	"NONE":    0,
  	"ASCEND":  1,
  	"DESCEND": 2,
  }
  
  func (x RangeRequest_SortOrder) String() string {
  	return proto.EnumName(RangeRequest_SortOrder_name, int32(x))
  }
  
  func (RangeRequest_SortOrder) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{1, 0}
  }
  
  type RangeRequest_SortTarget int32
  
  const (
  	RangeRequest_KEY     RangeRequest_SortTarget = 0
  	RangeRequest_VERSION RangeRequest_SortTarget = 1
  	RangeRequest_CREATE  RangeRequest_SortTarget = 2
  	RangeRequest_MOD     RangeRequest_SortTarget = 3
  	RangeRequest_VALUE   RangeRequest_SortTarget = 4
  )
  
  var RangeRequest_SortTarget_name = map[int32]string{
  	0: "KEY",
  	1: "VERSION",
  	2: "CREATE",
  	3: "MOD",
  	4: "VALUE",
  }
  
  var RangeRequest_SortTarget_value = map[string]int32{
  	"KEY":     0,
  	"VERSION": 1,
  	"CREATE":  2,
  	"MOD":     3,
  	"VALUE":   4,
  }
  
  func (x RangeRequest_SortTarget) String() string {
  	return proto.EnumName(RangeRequest_SortTarget_name, int32(x))
  }
  
  func (RangeRequest_SortTarget) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{1, 1}
  }
  
  type Compare_CompareResult int32
  
  const (
  	Compare_EQUAL     Compare_CompareResult = 0
  	Compare_GREATER   Compare_CompareResult = 1
  	Compare_LESS      Compare_CompareResult = 2
  	Compare_NOT_EQUAL Compare_CompareResult = 3
  )
  
  var Compare_CompareResult_name = map[int32]string{
  	0: "EQUAL",
  	1: "GREATER",
  	2: "LESS",
  	3: "NOT_EQUAL",
  }
  
  var Compare_CompareResult_value = map[string]int32{
  	"EQUAL":     0,
  	"GREATER":   1,
  	"LESS":      2,
  	"NOT_EQUAL": 3,
  }
  
  func (x Compare_CompareResult) String() string {
  	return proto.EnumName(Compare_CompareResult_name, int32(x))
  }
  
  func (Compare_CompareResult) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{9, 0}
  }
  
  type Compare_CompareTarget int32
  
  const (
  	Compare_VERSION Compare_CompareTarget = 0
  	Compare_CREATE  Compare_CompareTarget = 1
  	Compare_MOD     Compare_CompareTarget = 2
  	Compare_VALUE   Compare_CompareTarget = 3
  	Compare_LEASE   Compare_CompareTarget = 4
  )
  
  var Compare_CompareTarget_name = map[int32]string{
  	0: "VERSION",
  	1: "CREATE",
  	2: "MOD",
  	3: "VALUE",
  	4: "LEASE",
  }
  
  var Compare_CompareTarget_value = map[string]int32{
  	"VERSION": 0,
  	"CREATE":  1,
  	"MOD":     2,
  	"VALUE":   3,
  	"LEASE":   4,
  }
  
  func (x Compare_CompareTarget) String() string {
  	return proto.EnumName(Compare_CompareTarget_name, int32(x))
  }
  
  func (Compare_CompareTarget) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{9, 1}
  }
  
  type WatchCreateRequest_FilterType int32
  
  const (
  	// filter out put event.
  	WatchCreateRequest_NOPUT WatchCreateRequest_FilterType = 0
  	// filter out delete event.
  	WatchCreateRequest_NODELETE WatchCreateRequest_FilterType = 1
  )
  
  var WatchCreateRequest_FilterType_name = map[int32]string{
  	0: "NOPUT",
  	1: "NODELETE",
  }
  
  var WatchCreateRequest_FilterType_value = map[string]int32{
  	"NOPUT":    0,
  	"NODELETE": 1,
  }
  
  func (x WatchCreateRequest_FilterType) String() string {
  	return proto.EnumName(WatchCreateRequest_FilterType_name, int32(x))
  }
  
  func (WatchCreateRequest_FilterType) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{21, 0}
  }
  
  type AlarmRequest_AlarmAction int32
  
  const (
  	AlarmRequest_GET        AlarmRequest_AlarmAction = 0
  	AlarmRequest_ACTIVATE   AlarmRequest_AlarmAction = 1
  	AlarmRequest_DEACTIVATE AlarmRequest_AlarmAction = 2
  )
  
  var AlarmRequest_AlarmAction_name = map[int32]string{
  	0: "GET",
  	1: "ACTIVATE",
  	2: "DEACTIVATE",
  }
  
  var AlarmRequest_AlarmAction_value = map[string]int32{
  	"GET":        0,
  	"ACTIVATE":   1,
  	"DEACTIVATE": 2,
  }
  
  func (x AlarmRequest_AlarmAction) String() string {
  	return proto.EnumName(AlarmRequest_AlarmAction_name, int32(x))
  }
  
  func (AlarmRequest_AlarmAction) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{54, 0}
  }
  
  type DowngradeRequest_DowngradeAction int32
  
  const (
  	DowngradeRequest_VALIDATE DowngradeRequest_DowngradeAction = 0
  	DowngradeRequest_ENABLE   DowngradeRequest_DowngradeAction = 1
  	DowngradeRequest_CANCEL   DowngradeRequest_DowngradeAction = 2
  )
  
  var DowngradeRequest_DowngradeAction_name = map[int32]string{
  	0: "VALIDATE",
  	1: "ENABLE",
  	2: "CANCEL",
  }
  
  var DowngradeRequest_DowngradeAction_value = map[string]int32{
  	"VALIDATE": 0,
  	"ENABLE":   1,
  	"CANCEL":   2,
  }
  
  func (x DowngradeRequest_DowngradeAction) String() string {
  	return proto.EnumName(DowngradeRequest_DowngradeAction_name, int32(x))
  }
  
  func (DowngradeRequest_DowngradeAction) EnumDescriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{57, 0}
  }
  
  type ResponseHeader struct {
  	// cluster_id is the ID of the cluster which sent the response.
  	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
  	// member_id is the ID of the member which sent the response.
  	MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"`
  	// revision is the key-value store revision when the request was applied, and it's
  	// unset (so 0) in case of calls not interacting with key-value store.
  	// For watch progress responses, the header.revision indicates progress. All future events
  	// received in this stream are guaranteed to have a higher revision number than the
  	// header.revision number.
  	Revision int64 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
  	// raft_term is the raft term when the request was applied.
  	RaftTerm             uint64   `protobuf:"varint,4,opt,name=raft_term,json=raftTerm,proto3" json:"raft_term,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *ResponseHeader) Reset()         { *m = ResponseHeader{} }
  func (m *ResponseHeader) String() string { return proto.CompactTextString(m) }
  func (*ResponseHeader) ProtoMessage()    {}
  func (*ResponseHeader) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{0}
  }
  func (m *ResponseHeader) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *ResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_ResponseHeader.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *ResponseHeader) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_ResponseHeader.Merge(m, src)
  }
  func (m *ResponseHeader) XXX_Size() int {
  	return m.Size()
  }
  func (m *ResponseHeader) XXX_DiscardUnknown() {
  	xxx_messageInfo_ResponseHeader.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_ResponseHeader proto.InternalMessageInfo
  
  func (m *ResponseHeader) GetClusterId() uint64 {
  	if m != nil {
  		return m.ClusterId
  	}
  	return 0
  }
  
  func (m *ResponseHeader) GetMemberId() uint64 {
  	if m != nil {
  		return m.MemberId
  	}
  	return 0
  }
  
  func (m *ResponseHeader) GetRevision() int64 {
  	if m != nil {
  		return m.Revision
  	}
  	return 0
  }
  
  func (m *ResponseHeader) GetRaftTerm() uint64 {
  	if m != nil {
  		return m.RaftTerm
  	}
  	return 0
  }
  
  type RangeRequest struct {
  	// key is the first key for the range. If range_end is not given, the request only looks up key.
  	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  	// range_end is the upper bound on the requested range [key, range_end).
  	// If range_end is '\0', the range is all keys >= key.
  	// If range_end is key plus one (e.g., "aa"+1 == "ab", "a\xff"+1 == "b"),
  	// then the range request gets all keys prefixed with key.
  	// If both key and range_end are '\0', then the range request returns all keys.
  	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
  	// limit is a limit on the number of keys returned for the request. When limit is set to 0,
  	// it is treated as no limit.
  	Limit int64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
  	// revision is the point-in-time of the key-value store to use for the range.
  	// If revision is less or equal to zero, the range is over the newest key-value store.
  	// If the revision has been compacted, ErrCompacted is returned as a response.
  	Revision int64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
  	// sort_order is the order for returned sorted results.
  	SortOrder RangeRequest_SortOrder `protobuf:"varint,5,opt,name=sort_order,json=sortOrder,proto3,enum=etcdserverpb.RangeRequest_SortOrder" json:"sort_order,omitempty"`
  	// sort_target is the key-value field to use for sorting.
  	SortTarget RangeRequest_SortTarget `protobuf:"varint,6,opt,name=sort_target,json=sortTarget,proto3,enum=etcdserverpb.RangeRequest_SortTarget" json:"sort_target,omitempty"`
  	// serializable sets the range request to use serializable member-local reads.
  	// Range requests are linearizable by default; linearizable requests have higher
  	// latency and lower throughput than serializable requests but reflect the current
  	// consensus of the cluster. For better performance, in exchange for possible stale reads,
  	// a serializable range request is served locally without needing to reach consensus
  	// with other nodes in the cluster.
  	Serializable bool `protobuf:"varint,7,opt,name=serializable,proto3" json:"serializable,omitempty"`
  	// keys_only when set returns only the keys and not the values.
  	KeysOnly bool `protobuf:"varint,8,opt,name=keys_only,json=keysOnly,proto3" json:"keys_only,omitempty"`
  	// count_only when set returns only the count of the keys in the range.
  	CountOnly bool `protobuf:"varint,9,opt,name=count_only,json=countOnly,proto3" json:"count_only,omitempty"`
  	// min_mod_revision is the lower bound for returned key mod revisions; all keys with
  	// lesser mod revisions will be filtered away.
  	MinModRevision int64 `protobuf:"varint,10,opt,name=min_mod_revision,json=minModRevision,proto3" json:"min_mod_revision,omitempty"`
  	// max_mod_revision is the upper bound for returned key mod revisions; all keys with
  	// greater mod revisions will be filtered away.
  	MaxModRevision int64 `protobuf:"varint,11,opt,name=max_mod_revision,json=maxModRevision,proto3" json:"max_mod_revision,omitempty"`
  	// min_create_revision is the lower bound for returned key create revisions; all keys with
  	// lesser create revisions will be filtered away.
  	MinCreateRevision int64 `protobuf:"varint,12,opt,name=min_create_revision,json=minCreateRevision,proto3" json:"min_create_revision,omitempty"`
  	// max_create_revision is the upper bound for returned key create revisions; all keys with
  	// greater create revisions will be filtered away.
  	MaxCreateRevision    int64    `protobuf:"varint,13,opt,name=max_create_revision,json=maxCreateRevision,proto3" json:"max_create_revision,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *RangeRequest) Reset()         { *m = RangeRequest{} }
  func (m *RangeRequest) String() string { return proto.CompactTextString(m) }
  func (*RangeRequest) ProtoMessage()    {}
  func (*RangeRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{1}
  }
  func (m *RangeRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *RangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_RangeRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *RangeRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_RangeRequest.Merge(m, src)
  }
  func (m *RangeRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *RangeRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_RangeRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_RangeRequest proto.InternalMessageInfo
  
  func (m *RangeRequest) GetKey() []byte {
  	if m != nil {
  		return m.Key
  	}
  	return nil
  }
  
  func (m *RangeRequest) GetRangeEnd() []byte {
  	if m != nil {
  		return m.RangeEnd
  	}
  	return nil
  }
  
  func (m *RangeRequest) GetLimit() int64 {
  	if m != nil {
  		return m.Limit
  	}
  	return 0
  }
  
  func (m *RangeRequest) GetRevision() int64 {
  	if m != nil {
  		return m.Revision
  	}
  	return 0
  }
  
  func (m *RangeRequest) GetSortOrder() RangeRequest_SortOrder {
  	if m != nil {
  		return m.SortOrder
  	}
  	return RangeRequest_NONE
  }
  
  func (m *RangeRequest) GetSortTarget() RangeRequest_SortTarget {
  	if m != nil {
  		return m.SortTarget
  	}
  	return RangeRequest_KEY
  }
  
  func (m *RangeRequest) GetSerializable() bool {
  	if m != nil {
  		return m.Serializable
  	}
  	return false
  }
  
  func (m *RangeRequest) GetKeysOnly() bool {
  	if m != nil {
  		return m.KeysOnly
  	}
  	return false
  }
  
  func (m *RangeRequest) GetCountOnly() bool {
  	if m != nil {
  		return m.CountOnly
  	}
  	return false
  }
  
  func (m *RangeRequest) GetMinModRevision() int64 {
  	if m != nil {
  		return m.MinModRevision
  	}
  	return 0
  }
  
  func (m *RangeRequest) GetMaxModRevision() int64 {
  	if m != nil {
  		return m.MaxModRevision
  	}
  	return 0
  }
  
  func (m *RangeRequest) GetMinCreateRevision() int64 {
  	if m != nil {
  		return m.MinCreateRevision
  	}
  	return 0
  }
  
  func (m *RangeRequest) GetMaxCreateRevision() int64 {
  	if m != nil {
  		return m.MaxCreateRevision
  	}
  	return 0
  }
  
  type RangeResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// kvs is the list of key-value pairs matched by the range request.
  	// kvs is empty when count is requested.
  	Kvs []*mvccpb.KeyValue `protobuf:"bytes,2,rep,name=kvs,proto3" json:"kvs,omitempty"`
  	// more indicates if there are more keys to return in the requested range.
  	More bool `protobuf:"varint,3,opt,name=more,proto3" json:"more,omitempty"`
  	// count is set to the actual number of keys within the range when requested.
  	// Unlike Kvs, it is unaffected by limits and filters (e.g., Min/Max, Create/Modify, Revisions)
  	// and reflects the full count within the specified range.
  	Count                int64    `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *RangeResponse) Reset()         { *m = RangeResponse{} }
  func (m *RangeResponse) String() string { return proto.CompactTextString(m) }
  func (*RangeResponse) ProtoMessage()    {}
  func (*RangeResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{2}
  }
  func (m *RangeResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *RangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_RangeResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *RangeResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_RangeResponse.Merge(m, src)
  }
  func (m *RangeResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *RangeResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_RangeResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_RangeResponse proto.InternalMessageInfo
  
  func (m *RangeResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *RangeResponse) GetKvs() []*mvccpb.KeyValue {
  	if m != nil {
  		return m.Kvs
  	}
  	return nil
  }
  
  func (m *RangeResponse) GetMore() bool {
  	if m != nil {
  		return m.More
  	}
  	return false
  }
  
  func (m *RangeResponse) GetCount() int64 {
  	if m != nil {
  		return m.Count
  	}
  	return 0
  }
  
  type PutRequest struct {
  	// key is the key, in bytes, to put into the key-value store.
  	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  	// value is the value, in bytes, to associate with the key in the key-value store.
  	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
  	// lease is the lease ID to associate with the key in the key-value store. A lease
  	// value of 0 indicates no lease.
  	Lease int64 `protobuf:"varint,3,opt,name=lease,proto3" json:"lease,omitempty"`
  	// If prev_kv is set, etcd gets the previous key-value pair before changing it.
  	// The previous key-value pair will be returned in the put response.
  	PrevKv bool `protobuf:"varint,4,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
  	// If ignore_value is set, etcd updates the key using its current value.
  	// Returns an error if the key does not exist.
  	IgnoreValue bool `protobuf:"varint,5,opt,name=ignore_value,json=ignoreValue,proto3" json:"ignore_value,omitempty"`
  	// If ignore_lease is set, etcd updates the key using its current lease.
  	// Returns an error if the key does not exist.
  	IgnoreLease          bool     `protobuf:"varint,6,opt,name=ignore_lease,json=ignoreLease,proto3" json:"ignore_lease,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *PutRequest) Reset()         { *m = PutRequest{} }
  func (m *PutRequest) String() string { return proto.CompactTextString(m) }
  func (*PutRequest) ProtoMessage()    {}
  func (*PutRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{3}
  }
  func (m *PutRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *PutRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_PutRequest.Merge(m, src)
  }
  func (m *PutRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *PutRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_PutRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_PutRequest proto.InternalMessageInfo
  
  func (m *PutRequest) GetKey() []byte {
  	if m != nil {
  		return m.Key
  	}
  	return nil
  }
  
  func (m *PutRequest) GetValue() []byte {
  	if m != nil {
  		return m.Value
  	}
  	return nil
  }
  
  func (m *PutRequest) GetLease() int64 {
  	if m != nil {
  		return m.Lease
  	}
  	return 0
  }
  
  func (m *PutRequest) GetPrevKv() bool {
  	if m != nil {
  		return m.PrevKv
  	}
  	return false
  }
  
  func (m *PutRequest) GetIgnoreValue() bool {
  	if m != nil {
  		return m.IgnoreValue
  	}
  	return false
  }
  
  func (m *PutRequest) GetIgnoreLease() bool {
  	if m != nil {
  		return m.IgnoreLease
  	}
  	return false
  }
  
  type PutResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// if prev_kv is set in the request, the previous key-value pair will be returned.
  	PrevKv               *mvccpb.KeyValue `protobuf:"bytes,2,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
  	XXX_unrecognized     []byte           `json:"-"`
  	XXX_sizecache        int32            `json:"-"`
  }
  
  func (m *PutResponse) Reset()         { *m = PutResponse{} }
  func (m *PutResponse) String() string { return proto.CompactTextString(m) }
  func (*PutResponse) ProtoMessage()    {}
  func (*PutResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{4}
  }
  func (m *PutResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *PutResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_PutResponse.Merge(m, src)
  }
  func (m *PutResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *PutResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_PutResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_PutResponse proto.InternalMessageInfo
  
  func (m *PutResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *PutResponse) GetPrevKv() *mvccpb.KeyValue {
  	if m != nil {
  		return m.PrevKv
  	}
  	return nil
  }
  
  type DeleteRangeRequest struct {
  	// key is the first key to delete in the range.
  	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  	// range_end is the key following the last key to delete for the range [key, range_end).
  	// If range_end is not given, the range is defined to contain only the key argument.
  	// If range_end is one bit larger than the given key, then the range is all the keys
  	// with the prefix (the given key).
  	// If range_end is '\0', the range is all keys greater than or equal to the key argument.
  	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
  	// If prev_kv is set, etcd gets the previous key-value pairs before deleting it.
  	// The previous key-value pairs will be returned in the delete response.
  	PrevKv               bool     `protobuf:"varint,3,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *DeleteRangeRequest) Reset()         { *m = DeleteRangeRequest{} }
  func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) }
  func (*DeleteRangeRequest) ProtoMessage()    {}
  func (*DeleteRangeRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{5}
  }
  func (m *DeleteRangeRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DeleteRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DeleteRangeRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DeleteRangeRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DeleteRangeRequest.Merge(m, src)
  }
  func (m *DeleteRangeRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *DeleteRangeRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_DeleteRangeRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DeleteRangeRequest proto.InternalMessageInfo
  
  func (m *DeleteRangeRequest) GetKey() []byte {
  	if m != nil {
  		return m.Key
  	}
  	return nil
  }
  
  func (m *DeleteRangeRequest) GetRangeEnd() []byte {
  	if m != nil {
  		return m.RangeEnd
  	}
  	return nil
  }
  
  func (m *DeleteRangeRequest) GetPrevKv() bool {
  	if m != nil {
  		return m.PrevKv
  	}
  	return false
  }
  
  type DeleteRangeResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// deleted is the number of keys deleted by the delete range request.
  	Deleted int64 `protobuf:"varint,2,opt,name=deleted,proto3" json:"deleted,omitempty"`
  	// if prev_kv is set in the request, the previous key-value pairs will be returned.
  	PrevKvs              []*mvccpb.KeyValue `protobuf:"bytes,3,rep,name=prev_kvs,json=prevKvs,proto3" json:"prev_kvs,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
  	XXX_unrecognized     []byte             `json:"-"`
  	XXX_sizecache        int32              `json:"-"`
  }
  
  func (m *DeleteRangeResponse) Reset()         { *m = DeleteRangeResponse{} }
  func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) }
  func (*DeleteRangeResponse) ProtoMessage()    {}
  func (*DeleteRangeResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{6}
  }
  func (m *DeleteRangeResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DeleteRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DeleteRangeResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DeleteRangeResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DeleteRangeResponse.Merge(m, src)
  }
  func (m *DeleteRangeResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *DeleteRangeResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_DeleteRangeResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DeleteRangeResponse proto.InternalMessageInfo
  
  func (m *DeleteRangeResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *DeleteRangeResponse) GetDeleted() int64 {
  	if m != nil {
  		return m.Deleted
  	}
  	return 0
  }
  
  func (m *DeleteRangeResponse) GetPrevKvs() []*mvccpb.KeyValue {
  	if m != nil {
  		return m.PrevKvs
  	}
  	return nil
  }
  
  type RequestOp struct {
  	// request is a union of request types accepted by a transaction.
  	//
  	// Types that are valid to be assigned to Request:
  	//	*RequestOp_RequestRange
  	//	*RequestOp_RequestPut
  	//	*RequestOp_RequestDeleteRange
  	//	*RequestOp_RequestTxn
  	Request              isRequestOp_Request `protobuf_oneof:"request"`
  	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
  	XXX_unrecognized     []byte              `json:"-"`
  	XXX_sizecache        int32               `json:"-"`
  }
  
  func (m *RequestOp) Reset()         { *m = RequestOp{} }
  func (m *RequestOp) String() string { return proto.CompactTextString(m) }
  func (*RequestOp) ProtoMessage()    {}
  func (*RequestOp) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{7}
  }
  func (m *RequestOp) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *RequestOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_RequestOp.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *RequestOp) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_RequestOp.Merge(m, src)
  }
  func (m *RequestOp) XXX_Size() int {
  	return m.Size()
  }
  func (m *RequestOp) XXX_DiscardUnknown() {
  	xxx_messageInfo_RequestOp.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_RequestOp proto.InternalMessageInfo
  
  type isRequestOp_Request interface {
  	isRequestOp_Request()
  	MarshalTo([]byte) (int, error)
  	Size() int
  }
  
  type RequestOp_RequestRange struct {
  	RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range,json=requestRange,proto3,oneof" json:"request_range,omitempty"`
  }
  type RequestOp_RequestPut struct {
  	RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put,json=requestPut,proto3,oneof" json:"request_put,omitempty"`
  }
  type RequestOp_RequestDeleteRange struct {
  	RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,json=requestDeleteRange,proto3,oneof" json:"request_delete_range,omitempty"`
  }
  type RequestOp_RequestTxn struct {
  	RequestTxn *TxnRequest `protobuf:"bytes,4,opt,name=request_txn,json=requestTxn,proto3,oneof" json:"request_txn,omitempty"`
  }
  
  func (*RequestOp_RequestRange) isRequestOp_Request()       {}
  func (*RequestOp_RequestPut) isRequestOp_Request()         {}
  func (*RequestOp_RequestDeleteRange) isRequestOp_Request() {}
  func (*RequestOp_RequestTxn) isRequestOp_Request()         {}
  
  func (m *RequestOp) GetRequest() isRequestOp_Request {
  	if m != nil {
  		return m.Request
  	}
  	return nil
  }
  
  func (m *RequestOp) GetRequestRange() *RangeRequest {
  	if x, ok := m.GetRequest().(*RequestOp_RequestRange); ok {
  		return x.RequestRange
  	}
  	return nil
  }
  
  func (m *RequestOp) GetRequestPut() *PutRequest {
  	if x, ok := m.GetRequest().(*RequestOp_RequestPut); ok {
  		return x.RequestPut
  	}
  	return nil
  }
  
  func (m *RequestOp) GetRequestDeleteRange() *DeleteRangeRequest {
  	if x, ok := m.GetRequest().(*RequestOp_RequestDeleteRange); ok {
  		return x.RequestDeleteRange
  	}
  	return nil
  }
  
  func (m *RequestOp) GetRequestTxn() *TxnRequest {
  	if x, ok := m.GetRequest().(*RequestOp_RequestTxn); ok {
  		return x.RequestTxn
  	}
  	return nil
  }
  
  // XXX_OneofWrappers is for the internal use of the proto package.
  func (*RequestOp) XXX_OneofWrappers() []interface{} {
  	return []interface{}{
  		(*RequestOp_RequestRange)(nil),
  		(*RequestOp_RequestPut)(nil),
  		(*RequestOp_RequestDeleteRange)(nil),
  		(*RequestOp_RequestTxn)(nil),
  	}
  }
  
  type ResponseOp struct {
  	// response is a union of response types returned by a transaction.
  	//
  	// Types that are valid to be assigned to Response:
  	//	*ResponseOp_ResponseRange
  	//	*ResponseOp_ResponsePut
  	//	*ResponseOp_ResponseDeleteRange
  	//	*ResponseOp_ResponseTxn
  	Response             isResponseOp_Response `protobuf_oneof:"response"`
  	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
  	XXX_unrecognized     []byte                `json:"-"`
  	XXX_sizecache        int32                 `json:"-"`
  }
  
  func (m *ResponseOp) Reset()         { *m = ResponseOp{} }
  func (m *ResponseOp) String() string { return proto.CompactTextString(m) }
  func (*ResponseOp) ProtoMessage()    {}
  func (*ResponseOp) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{8}
  }
  func (m *ResponseOp) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *ResponseOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_ResponseOp.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *ResponseOp) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_ResponseOp.Merge(m, src)
  }
  func (m *ResponseOp) XXX_Size() int {
  	return m.Size()
  }
  func (m *ResponseOp) XXX_DiscardUnknown() {
  	xxx_messageInfo_ResponseOp.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_ResponseOp proto.InternalMessageInfo
  
  type isResponseOp_Response interface {
  	isResponseOp_Response()
  	MarshalTo([]byte) (int, error)
  	Size() int
  }
  
  type ResponseOp_ResponseRange struct {
  	ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range,json=responseRange,proto3,oneof" json:"response_range,omitempty"`
  }
  type ResponseOp_ResponsePut struct {
  	ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put,json=responsePut,proto3,oneof" json:"response_put,omitempty"`
  }
  type ResponseOp_ResponseDeleteRange struct {
  	ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,json=responseDeleteRange,proto3,oneof" json:"response_delete_range,omitempty"`
  }
  type ResponseOp_ResponseTxn struct {
  	ResponseTxn *TxnResponse `protobuf:"bytes,4,opt,name=response_txn,json=responseTxn,proto3,oneof" json:"response_txn,omitempty"`
  }
  
  func (*ResponseOp_ResponseRange) isResponseOp_Response()       {}
  func (*ResponseOp_ResponsePut) isResponseOp_Response()         {}
  func (*ResponseOp_ResponseDeleteRange) isResponseOp_Response() {}
  func (*ResponseOp_ResponseTxn) isResponseOp_Response()         {}
  
  func (m *ResponseOp) GetResponse() isResponseOp_Response {
  	if m != nil {
  		return m.Response
  	}
  	return nil
  }
  
  func (m *ResponseOp) GetResponseRange() *RangeResponse {
  	if x, ok := m.GetResponse().(*ResponseOp_ResponseRange); ok {
  		return x.ResponseRange
  	}
  	return nil
  }
  
  func (m *ResponseOp) GetResponsePut() *PutResponse {
  	if x, ok := m.GetResponse().(*ResponseOp_ResponsePut); ok {
  		return x.ResponsePut
  	}
  	return nil
  }
  
  func (m *ResponseOp) GetResponseDeleteRange() *DeleteRangeResponse {
  	if x, ok := m.GetResponse().(*ResponseOp_ResponseDeleteRange); ok {
  		return x.ResponseDeleteRange
  	}
  	return nil
  }
  
  func (m *ResponseOp) GetResponseTxn() *TxnResponse {
  	if x, ok := m.GetResponse().(*ResponseOp_ResponseTxn); ok {
  		return x.ResponseTxn
  	}
  	return nil
  }
  
  // XXX_OneofWrappers is for the internal use of the proto package.
  func (*ResponseOp) XXX_OneofWrappers() []interface{} {
  	return []interface{}{
  		(*ResponseOp_ResponseRange)(nil),
  		(*ResponseOp_ResponsePut)(nil),
  		(*ResponseOp_ResponseDeleteRange)(nil),
  		(*ResponseOp_ResponseTxn)(nil),
  	}
  }
  
  type Compare struct {
  	// result is logical comparison operation for this comparison.
  	Result Compare_CompareResult `protobuf:"varint,1,opt,name=result,proto3,enum=etcdserverpb.Compare_CompareResult" json:"result,omitempty"`
  	// target is the key-value field to inspect for the comparison.
  	Target Compare_CompareTarget `protobuf:"varint,2,opt,name=target,proto3,enum=etcdserverpb.Compare_CompareTarget" json:"target,omitempty"`
  	// key is the subject key for the comparison operation.
  	Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
  	// Types that are valid to be assigned to TargetUnion:
  	//	*Compare_Version
  	//	*Compare_CreateRevision
  	//	*Compare_ModRevision
  	//	*Compare_Value
  	//	*Compare_Lease
  	TargetUnion isCompare_TargetUnion `protobuf_oneof:"target_union"`
  	// range_end compares the given target to all keys in the range [key, range_end).
  	// See RangeRequest for more details on key ranges.
  	RangeEnd             []byte   `protobuf:"bytes,64,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *Compare) Reset()         { *m = Compare{} }
  func (m *Compare) String() string { return proto.CompactTextString(m) }
  func (*Compare) ProtoMessage()    {}
  func (*Compare) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{9}
  }
  func (m *Compare) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *Compare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_Compare.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *Compare) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_Compare.Merge(m, src)
  }
  func (m *Compare) XXX_Size() int {
  	return m.Size()
  }
  func (m *Compare) XXX_DiscardUnknown() {
  	xxx_messageInfo_Compare.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_Compare proto.InternalMessageInfo
  
  type isCompare_TargetUnion interface {
  	isCompare_TargetUnion()
  	MarshalTo([]byte) (int, error)
  	Size() int
  }
  
  type Compare_Version struct {
  	Version int64 `protobuf:"varint,4,opt,name=version,proto3,oneof" json:"version,omitempty"`
  }
  type Compare_CreateRevision struct {
  	CreateRevision int64 `protobuf:"varint,5,opt,name=create_revision,json=createRevision,proto3,oneof" json:"create_revision,omitempty"`
  }
  type Compare_ModRevision struct {
  	ModRevision int64 `protobuf:"varint,6,opt,name=mod_revision,json=modRevision,proto3,oneof" json:"mod_revision,omitempty"`
  }
  type Compare_Value struct {
  	Value []byte `protobuf:"bytes,7,opt,name=value,proto3,oneof" json:"value,omitempty"`
  }
  type Compare_Lease struct {
  	Lease int64 `protobuf:"varint,8,opt,name=lease,proto3,oneof" json:"lease,omitempty"`
  }
  
  func (*Compare_Version) isCompare_TargetUnion()        {}
  func (*Compare_CreateRevision) isCompare_TargetUnion() {}
  func (*Compare_ModRevision) isCompare_TargetUnion()    {}
  func (*Compare_Value) isCompare_TargetUnion()          {}
  func (*Compare_Lease) isCompare_TargetUnion()          {}
  
  func (m *Compare) GetTargetUnion() isCompare_TargetUnion {
  	if m != nil {
  		return m.TargetUnion
  	}
  	return nil
  }
  
  func (m *Compare) GetResult() Compare_CompareResult {
  	if m != nil {
  		return m.Result
  	}
  	return Compare_EQUAL
  }
  
  func (m *Compare) GetTarget() Compare_CompareTarget {
  	if m != nil {
  		return m.Target
  	}
  	return Compare_VERSION
  }
  
  func (m *Compare) GetKey() []byte {
  	if m != nil {
  		return m.Key
  	}
  	return nil
  }
  
  func (m *Compare) GetVersion() int64 {
  	if x, ok := m.GetTargetUnion().(*Compare_Version); ok {
  		return x.Version
  	}
  	return 0
  }
  
  func (m *Compare) GetCreateRevision() int64 {
  	if x, ok := m.GetTargetUnion().(*Compare_CreateRevision); ok {
  		return x.CreateRevision
  	}
  	return 0
  }
  
  func (m *Compare) GetModRevision() int64 {
  	if x, ok := m.GetTargetUnion().(*Compare_ModRevision); ok {
  		return x.ModRevision
  	}
  	return 0
  }
  
  func (m *Compare) GetValue() []byte {
  	if x, ok := m.GetTargetUnion().(*Compare_Value); ok {
  		return x.Value
  	}
  	return nil
  }
  
  func (m *Compare) GetLease() int64 {
  	if x, ok := m.GetTargetUnion().(*Compare_Lease); ok {
  		return x.Lease
  	}
  	return 0
  }
  
  func (m *Compare) GetRangeEnd() []byte {
  	if m != nil {
  		return m.RangeEnd
  	}
  	return nil
  }
  
  // XXX_OneofWrappers is for the internal use of the proto package.
  func (*Compare) XXX_OneofWrappers() []interface{} {
  	return []interface{}{
  		(*Compare_Version)(nil),
  		(*Compare_CreateRevision)(nil),
  		(*Compare_ModRevision)(nil),
  		(*Compare_Value)(nil),
  		(*Compare_Lease)(nil),
  	}
  }
  
  // From google paxosdb paper:
  // Our implementation hinges around a powerful primitive which we call MultiOp. All other database
  // operations except for iteration are implemented as a single call to MultiOp. A MultiOp is applied atomically
  // and consists of three components:
  // 1. A list of tests called guard. Each test in guard checks a single entry in the database. It may check
  // for the absence or presence of a value, or compare with a given value. Two different tests in the guard
  // may apply to the same or different entries in the database. All tests in the guard are applied and
  // MultiOp returns the results. If all tests are true, MultiOp executes t op (see item 2 below), otherwise
  // it executes f op (see item 3 below).
  // 2. A list of database operations called t op. Each operation in the list is either an insert, delete, or
  // lookup operation, and applies to a single database entry. Two different operations in the list may apply
  // to the same or different entries in the database. These operations are executed
  // if guard evaluates to
  // true.
  // 3. A list of database operations called f op. Like t op, but executed if guard evaluates to false.
  type TxnRequest struct {
  	// compare is a list of predicates representing a conjunction of terms.
  	// If the comparisons succeed, then the success requests will be processed in order,
  	// and the response will contain their respective responses in order.
  	// If the comparisons fail, then the failure requests will be processed in order,
  	// and the response will contain their respective responses in order.
  	Compare []*Compare `protobuf:"bytes,1,rep,name=compare,proto3" json:"compare,omitempty"`
  	// success is a list of requests which will be applied when compare evaluates to true.
  	Success []*RequestOp `protobuf:"bytes,2,rep,name=success,proto3" json:"success,omitempty"`
  	// failure is a list of requests which will be applied when compare evaluates to false.
  	Failure              []*RequestOp `protobuf:"bytes,3,rep,name=failure,proto3" json:"failure,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
  	XXX_unrecognized     []byte       `json:"-"`
  	XXX_sizecache        int32        `json:"-"`
  }
  
  func (m *TxnRequest) Reset()         { *m = TxnRequest{} }
  func (m *TxnRequest) String() string { return proto.CompactTextString(m) }
  func (*TxnRequest) ProtoMessage()    {}
  func (*TxnRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{10}
  }
  func (m *TxnRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *TxnRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_TxnRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *TxnRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_TxnRequest.Merge(m, src)
  }
  func (m *TxnRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *TxnRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_TxnRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_TxnRequest proto.InternalMessageInfo
  
  func (m *TxnRequest) GetCompare() []*Compare {
  	if m != nil {
  		return m.Compare
  	}
  	return nil
  }
  
  func (m *TxnRequest) GetSuccess() []*RequestOp {
  	if m != nil {
  		return m.Success
  	}
  	return nil
  }
  
  func (m *TxnRequest) GetFailure() []*RequestOp {
  	if m != nil {
  		return m.Failure
  	}
  	return nil
  }
  
  type TxnResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// succeeded is set to true if the compare evaluated to true or false otherwise.
  	Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
  	// responses is a list of responses corresponding to the results from applying
  	// success if succeeded is true or failure if succeeded is false.
  	Responses            []*ResponseOp `protobuf:"bytes,3,rep,name=responses,proto3" json:"responses,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
  	XXX_unrecognized     []byte        `json:"-"`
  	XXX_sizecache        int32         `json:"-"`
  }
  
  func (m *TxnResponse) Reset()         { *m = TxnResponse{} }
  func (m *TxnResponse) String() string { return proto.CompactTextString(m) }
  func (*TxnResponse) ProtoMessage()    {}
  func (*TxnResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{11}
  }
  func (m *TxnResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *TxnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_TxnResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *TxnResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_TxnResponse.Merge(m, src)
  }
  func (m *TxnResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *TxnResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_TxnResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_TxnResponse proto.InternalMessageInfo
  
  func (m *TxnResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *TxnResponse) GetSucceeded() bool {
  	if m != nil {
  		return m.Succeeded
  	}
  	return false
  }
  
  func (m *TxnResponse) GetResponses() []*ResponseOp {
  	if m != nil {
  		return m.Responses
  	}
  	return nil
  }
  
  // CompactionRequest compacts the key-value store up to a given revision. All superseded keys
  // with a revision less than the compaction revision will be removed.
  type CompactionRequest struct {
  	// revision is the key-value store revision for the compaction operation.
  	Revision int64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
  	// physical is set so the RPC will wait until the compaction is physically
  	// applied to the local database such that compacted entries are totally
  	// removed from the backend database.
  	Physical             bool     `protobuf:"varint,2,opt,name=physical,proto3" json:"physical,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *CompactionRequest) Reset()         { *m = CompactionRequest{} }
  func (m *CompactionRequest) String() string { return proto.CompactTextString(m) }
  func (*CompactionRequest) ProtoMessage()    {}
  func (*CompactionRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{12}
  }
  func (m *CompactionRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *CompactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_CompactionRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *CompactionRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_CompactionRequest.Merge(m, src)
  }
  func (m *CompactionRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *CompactionRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_CompactionRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_CompactionRequest proto.InternalMessageInfo
  
  func (m *CompactionRequest) GetRevision() int64 {
  	if m != nil {
  		return m.Revision
  	}
  	return 0
  }
  
  func (m *CompactionRequest) GetPhysical() bool {
  	if m != nil {
  		return m.Physical
  	}
  	return false
  }
  
  type CompactionResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *CompactionResponse) Reset()         { *m = CompactionResponse{} }
  func (m *CompactionResponse) String() string { return proto.CompactTextString(m) }
  func (*CompactionResponse) ProtoMessage()    {}
  func (*CompactionResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{13}
  }
  func (m *CompactionResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *CompactionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_CompactionResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *CompactionResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_CompactionResponse.Merge(m, src)
  }
  func (m *CompactionResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *CompactionResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_CompactionResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_CompactionResponse proto.InternalMessageInfo
  
  func (m *CompactionResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type HashRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *HashRequest) Reset()         { *m = HashRequest{} }
  func (m *HashRequest) String() string { return proto.CompactTextString(m) }
  func (*HashRequest) ProtoMessage()    {}
  func (*HashRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{14}
  }
  func (m *HashRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *HashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_HashRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *HashRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_HashRequest.Merge(m, src)
  }
  func (m *HashRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *HashRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_HashRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_HashRequest proto.InternalMessageInfo
  
  type HashKVRequest struct {
  	// revision is the key-value store revision for the hash operation.
  	Revision             int64    `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *HashKVRequest) Reset()         { *m = HashKVRequest{} }
  func (m *HashKVRequest) String() string { return proto.CompactTextString(m) }
  func (*HashKVRequest) ProtoMessage()    {}
  func (*HashKVRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{15}
  }
  func (m *HashKVRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *HashKVRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_HashKVRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *HashKVRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_HashKVRequest.Merge(m, src)
  }
  func (m *HashKVRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *HashKVRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_HashKVRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_HashKVRequest proto.InternalMessageInfo
  
  func (m *HashKVRequest) GetRevision() int64 {
  	if m != nil {
  		return m.Revision
  	}
  	return 0
  }
  
  type HashKVResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// hash is the hash value computed from the responding member's MVCC keys up to a given revision.
  	Hash uint32 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"`
  	// compact_revision is the compacted revision of key-value store when hash begins.
  	CompactRevision int64 `protobuf:"varint,3,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
  	// hash_revision is the revision up to which the hash is calculated.
  	HashRevision         int64    `protobuf:"varint,4,opt,name=hash_revision,json=hashRevision,proto3" json:"hash_revision,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *HashKVResponse) Reset()         { *m = HashKVResponse{} }
  func (m *HashKVResponse) String() string { return proto.CompactTextString(m) }
  func (*HashKVResponse) ProtoMessage()    {}
  func (*HashKVResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{16}
  }
  func (m *HashKVResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *HashKVResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_HashKVResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *HashKVResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_HashKVResponse.Merge(m, src)
  }
  func (m *HashKVResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *HashKVResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_HashKVResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_HashKVResponse proto.InternalMessageInfo
  
  func (m *HashKVResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *HashKVResponse) GetHash() uint32 {
  	if m != nil {
  		return m.Hash
  	}
  	return 0
  }
  
  func (m *HashKVResponse) GetCompactRevision() int64 {
  	if m != nil {
  		return m.CompactRevision
  	}
  	return 0
  }
  
  func (m *HashKVResponse) GetHashRevision() int64 {
  	if m != nil {
  		return m.HashRevision
  	}
  	return 0
  }
  
  type HashResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// hash is the hash value computed from the responding member's KV's backend.
  	Hash                 uint32   `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *HashResponse) Reset()         { *m = HashResponse{} }
  func (m *HashResponse) String() string { return proto.CompactTextString(m) }
  func (*HashResponse) ProtoMessage()    {}
  func (*HashResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{17}
  }
  func (m *HashResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *HashResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_HashResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *HashResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_HashResponse.Merge(m, src)
  }
  func (m *HashResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *HashResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_HashResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_HashResponse proto.InternalMessageInfo
  
  func (m *HashResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *HashResponse) GetHash() uint32 {
  	if m != nil {
  		return m.Hash
  	}
  	return 0
  }
  
  type SnapshotRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *SnapshotRequest) Reset()         { *m = SnapshotRequest{} }
  func (m *SnapshotRequest) String() string { return proto.CompactTextString(m) }
  func (*SnapshotRequest) ProtoMessage()    {}
  func (*SnapshotRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{18}
  }
  func (m *SnapshotRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *SnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_SnapshotRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *SnapshotRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_SnapshotRequest.Merge(m, src)
  }
  func (m *SnapshotRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *SnapshotRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_SnapshotRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_SnapshotRequest proto.InternalMessageInfo
  
  type SnapshotResponse struct {
  	// header has the current key-value store information. The first header in the snapshot
  	// stream indicates the point in time of the snapshot.
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// remaining_bytes is the number of blob bytes to be sent after this message
  	RemainingBytes uint64 `protobuf:"varint,2,opt,name=remaining_bytes,json=remainingBytes,proto3" json:"remaining_bytes,omitempty"`
  	// blob contains the next chunk of the snapshot in the snapshot stream.
  	Blob []byte `protobuf:"bytes,3,opt,name=blob,proto3" json:"blob,omitempty"`
  	// local version of server that created the snapshot.
  	// In cluster with binaries with different version, each cluster can return different result.
  	// Informs which etcd server version should be used when restoring the snapshot.
  	Version              string   `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *SnapshotResponse) Reset()         { *m = SnapshotResponse{} }
  func (m *SnapshotResponse) String() string { return proto.CompactTextString(m) }
  func (*SnapshotResponse) ProtoMessage()    {}
  func (*SnapshotResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{19}
  }
  func (m *SnapshotResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *SnapshotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_SnapshotResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *SnapshotResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_SnapshotResponse.Merge(m, src)
  }
  func (m *SnapshotResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *SnapshotResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_SnapshotResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_SnapshotResponse proto.InternalMessageInfo
  
  func (m *SnapshotResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *SnapshotResponse) GetRemainingBytes() uint64 {
  	if m != nil {
  		return m.RemainingBytes
  	}
  	return 0
  }
  
  func (m *SnapshotResponse) GetBlob() []byte {
  	if m != nil {
  		return m.Blob
  	}
  	return nil
  }
  
  func (m *SnapshotResponse) GetVersion() string {
  	if m != nil {
  		return m.Version
  	}
  	return ""
  }
  
  type WatchRequest struct {
  	// request_union is a request to either create a new watcher or cancel an existing watcher.
  	//
  	// Types that are valid to be assigned to RequestUnion:
  	//	*WatchRequest_CreateRequest
  	//	*WatchRequest_CancelRequest
  	//	*WatchRequest_ProgressRequest
  	RequestUnion         isWatchRequest_RequestUnion `protobuf_oneof:"request_union"`
  	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
  	XXX_unrecognized     []byte                      `json:"-"`
  	XXX_sizecache        int32                       `json:"-"`
  }
  
  func (m *WatchRequest) Reset()         { *m = WatchRequest{} }
  func (m *WatchRequest) String() string { return proto.CompactTextString(m) }
  func (*WatchRequest) ProtoMessage()    {}
  func (*WatchRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{20}
  }
  func (m *WatchRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *WatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_WatchRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *WatchRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_WatchRequest.Merge(m, src)
  }
  func (m *WatchRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *WatchRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_WatchRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_WatchRequest proto.InternalMessageInfo
  
  type isWatchRequest_RequestUnion interface {
  	isWatchRequest_RequestUnion()
  	MarshalTo([]byte) (int, error)
  	Size() int
  }
  
  type WatchRequest_CreateRequest struct {
  	CreateRequest *WatchCreateRequest `protobuf:"bytes,1,opt,name=create_request,json=createRequest,proto3,oneof" json:"create_request,omitempty"`
  }
  type WatchRequest_CancelRequest struct {
  	CancelRequest *WatchCancelRequest `protobuf:"bytes,2,opt,name=cancel_request,json=cancelRequest,proto3,oneof" json:"cancel_request,omitempty"`
  }
  type WatchRequest_ProgressRequest struct {
  	ProgressRequest *WatchProgressRequest `protobuf:"bytes,3,opt,name=progress_request,json=progressRequest,proto3,oneof" json:"progress_request,omitempty"`
  }
  
  func (*WatchRequest_CreateRequest) isWatchRequest_RequestUnion()   {}
  func (*WatchRequest_CancelRequest) isWatchRequest_RequestUnion()   {}
  func (*WatchRequest_ProgressRequest) isWatchRequest_RequestUnion() {}
  
  func (m *WatchRequest) GetRequestUnion() isWatchRequest_RequestUnion {
  	if m != nil {
  		return m.RequestUnion
  	}
  	return nil
  }
  
  func (m *WatchRequest) GetCreateRequest() *WatchCreateRequest {
  	if x, ok := m.GetRequestUnion().(*WatchRequest_CreateRequest); ok {
  		return x.CreateRequest
  	}
  	return nil
  }
  
  func (m *WatchRequest) GetCancelRequest() *WatchCancelRequest {
  	if x, ok := m.GetRequestUnion().(*WatchRequest_CancelRequest); ok {
  		return x.CancelRequest
  	}
  	return nil
  }
  
  func (m *WatchRequest) GetProgressRequest() *WatchProgressRequest {
  	if x, ok := m.GetRequestUnion().(*WatchRequest_ProgressRequest); ok {
  		return x.ProgressRequest
  	}
  	return nil
  }
  
  // XXX_OneofWrappers is for the internal use of the proto package.
  func (*WatchRequest) XXX_OneofWrappers() []interface{} {
  	return []interface{}{
  		(*WatchRequest_CreateRequest)(nil),
  		(*WatchRequest_CancelRequest)(nil),
  		(*WatchRequest_ProgressRequest)(nil),
  	}
  }
  
  type WatchCreateRequest struct {
  	// key is the key to register for watching.
  	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  	// range_end is the end of the range [key, range_end) to watch. If range_end is not given,
  	// only the key argument is watched. If range_end is equal to '\0', all keys greater than
  	// or equal to the key argument are watched.
  	// If the range_end is one bit larger than the given key,
  	// then all keys with the prefix (the given key) will be watched.
  	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
  	// start_revision is an optional revision to watch from (inclusive). No start_revision is "now".
  	StartRevision int64 `protobuf:"varint,3,opt,name=start_revision,json=startRevision,proto3" json:"start_revision,omitempty"`
  	// progress_notify is set so that the etcd server will periodically send a WatchResponse with
  	// no events to the new watcher if there are no recent events. It is useful when clients
  	// wish to recover a disconnected watcher starting from a recent known revision.
  	// The etcd server may decide how often it will send notifications based on current load.
  	ProgressNotify bool `protobuf:"varint,4,opt,name=progress_notify,json=progressNotify,proto3" json:"progress_notify,omitempty"`
  	// filters filter the events at server side before it sends back to the watcher.
  	Filters []WatchCreateRequest_FilterType `protobuf:"varint,5,rep,packed,name=filters,proto3,enum=etcdserverpb.WatchCreateRequest_FilterType" json:"filters,omitempty"`
  	// If prev_kv is set, created watcher gets the previous KV before the event happens.
  	// If the previous KV is already compacted, nothing will be returned.
  	PrevKv bool `protobuf:"varint,6,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
  	// If watch_id is provided and non-zero, it will be assigned to this watcher.
  	// Since creating a watcher in etcd is not a synchronous operation,
  	// this can be used ensure that ordering is correct when creating multiple
  	// watchers on the same stream. Creating a watcher with an ID already in
  	// use on the stream will cause an error to be returned.
  	WatchId int64 `protobuf:"varint,7,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
  	// fragment enables splitting large revisions into multiple watch responses.
  	Fragment             bool     `protobuf:"varint,8,opt,name=fragment,proto3" json:"fragment,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *WatchCreateRequest) Reset()         { *m = WatchCreateRequest{} }
  func (m *WatchCreateRequest) String() string { return proto.CompactTextString(m) }
  func (*WatchCreateRequest) ProtoMessage()    {}
  func (*WatchCreateRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{21}
  }
  func (m *WatchCreateRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *WatchCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_WatchCreateRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *WatchCreateRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_WatchCreateRequest.Merge(m, src)
  }
  func (m *WatchCreateRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *WatchCreateRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_WatchCreateRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_WatchCreateRequest proto.InternalMessageInfo
  
  func (m *WatchCreateRequest) GetKey() []byte {
  	if m != nil {
  		return m.Key
  	}
  	return nil
  }
  
  func (m *WatchCreateRequest) GetRangeEnd() []byte {
  	if m != nil {
  		return m.RangeEnd
  	}
  	return nil
  }
  
  func (m *WatchCreateRequest) GetStartRevision() int64 {
  	if m != nil {
  		return m.StartRevision
  	}
  	return 0
  }
  
  func (m *WatchCreateRequest) GetProgressNotify() bool {
  	if m != nil {
  		return m.ProgressNotify
  	}
  	return false
  }
  
  func (m *WatchCreateRequest) GetFilters() []WatchCreateRequest_FilterType {
  	if m != nil {
  		return m.Filters
  	}
  	return nil
  }
  
  func (m *WatchCreateRequest) GetPrevKv() bool {
  	if m != nil {
  		return m.PrevKv
  	}
  	return false
  }
  
  func (m *WatchCreateRequest) GetWatchId() int64 {
  	if m != nil {
  		return m.WatchId
  	}
  	return 0
  }
  
  func (m *WatchCreateRequest) GetFragment() bool {
  	if m != nil {
  		return m.Fragment
  	}
  	return false
  }
  
  type WatchCancelRequest struct {
  	// watch_id is the watcher id to cancel so that no more events are transmitted.
  	WatchId              int64    `protobuf:"varint,1,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *WatchCancelRequest) Reset()         { *m = WatchCancelRequest{} }
  func (m *WatchCancelRequest) String() string { return proto.CompactTextString(m) }
  func (*WatchCancelRequest) ProtoMessage()    {}
  func (*WatchCancelRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{22}
  }
  func (m *WatchCancelRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *WatchCancelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_WatchCancelRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *WatchCancelRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_WatchCancelRequest.Merge(m, src)
  }
  func (m *WatchCancelRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *WatchCancelRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_WatchCancelRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_WatchCancelRequest proto.InternalMessageInfo
  
  func (m *WatchCancelRequest) GetWatchId() int64 {
  	if m != nil {
  		return m.WatchId
  	}
  	return 0
  }
  
  // Requests the a watch stream progress status be sent in the watch response stream as soon as
  // possible.
  type WatchProgressRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *WatchProgressRequest) Reset()         { *m = WatchProgressRequest{} }
  func (m *WatchProgressRequest) String() string { return proto.CompactTextString(m) }
  func (*WatchProgressRequest) ProtoMessage()    {}
  func (*WatchProgressRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{23}
  }
  func (m *WatchProgressRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *WatchProgressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_WatchProgressRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *WatchProgressRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_WatchProgressRequest.Merge(m, src)
  }
  func (m *WatchProgressRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *WatchProgressRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_WatchProgressRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_WatchProgressRequest proto.InternalMessageInfo
  
  type WatchResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// watch_id is the ID of the watcher that corresponds to the response.
  	WatchId int64 `protobuf:"varint,2,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
  	// created is set to true if the response is for a create watch request.
  	// The client should record the watch_id and expect to receive events for
  	// the created watcher from the same stream.
  	// All events sent to the created watcher will attach with the same watch_id.
  	Created bool `protobuf:"varint,3,opt,name=created,proto3" json:"created,omitempty"`
  	// canceled is set to true if the response is for a cancel watch request
  	// or if the start_revision has already been compacted.
  	// No further events will be sent to the canceled watcher.
  	Canceled bool `protobuf:"varint,4,opt,name=canceled,proto3" json:"canceled,omitempty"`
  	// compact_revision is set to the minimum index if a watcher tries to watch
  	// at a compacted index.
  	//
  	// This happens when creating a watcher at a compacted revision or the watcher cannot
  	// catch up with the progress of the key-value store.
  	//
  	// The client should treat the watcher as canceled and should not try to create any
  	// watcher with the same start_revision again.
  	CompactRevision int64 `protobuf:"varint,5,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
  	// cancel_reason indicates the reason for canceling the watcher.
  	CancelReason string `protobuf:"bytes,6,opt,name=cancel_reason,json=cancelReason,proto3" json:"cancel_reason,omitempty"`
  	// framgment is true if large watch response was split over multiple responses.
  	Fragment             bool            `protobuf:"varint,7,opt,name=fragment,proto3" json:"fragment,omitempty"`
  	Events               []*mvccpb.Event `protobuf:"bytes,11,rep,name=events,proto3" json:"events,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *WatchResponse) Reset()         { *m = WatchResponse{} }
  func (m *WatchResponse) String() string { return proto.CompactTextString(m) }
  func (*WatchResponse) ProtoMessage()    {}
  func (*WatchResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{24}
  }
  func (m *WatchResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *WatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_WatchResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *WatchResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_WatchResponse.Merge(m, src)
  }
  func (m *WatchResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *WatchResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_WatchResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_WatchResponse proto.InternalMessageInfo
  
  func (m *WatchResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *WatchResponse) GetWatchId() int64 {
  	if m != nil {
  		return m.WatchId
  	}
  	return 0
  }
  
  func (m *WatchResponse) GetCreated() bool {
  	if m != nil {
  		return m.Created
  	}
  	return false
  }
  
  func (m *WatchResponse) GetCanceled() bool {
  	if m != nil {
  		return m.Canceled
  	}
  	return false
  }
  
  func (m *WatchResponse) GetCompactRevision() int64 {
  	if m != nil {
  		return m.CompactRevision
  	}
  	return 0
  }
  
  func (m *WatchResponse) GetCancelReason() string {
  	if m != nil {
  		return m.CancelReason
  	}
  	return ""
  }
  
  func (m *WatchResponse) GetFragment() bool {
  	if m != nil {
  		return m.Fragment
  	}
  	return false
  }
  
  func (m *WatchResponse) GetEvents() []*mvccpb.Event {
  	if m != nil {
  		return m.Events
  	}
  	return nil
  }
  
  type LeaseGrantRequest struct {
  	// TTL is the advisory time-to-live in seconds. Expired lease will return -1.
  	TTL int64 `protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
  	// ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID.
  	ID                   int64    `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseGrantRequest) Reset()         { *m = LeaseGrantRequest{} }
  func (m *LeaseGrantRequest) String() string { return proto.CompactTextString(m) }
  func (*LeaseGrantRequest) ProtoMessage()    {}
  func (*LeaseGrantRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{25}
  }
  func (m *LeaseGrantRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseGrantRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseGrantRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseGrantRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseGrantRequest.Merge(m, src)
  }
  func (m *LeaseGrantRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseGrantRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseGrantRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseGrantRequest proto.InternalMessageInfo
  
  func (m *LeaseGrantRequest) GetTTL() int64 {
  	if m != nil {
  		return m.TTL
  	}
  	return 0
  }
  
  func (m *LeaseGrantRequest) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  type LeaseGrantResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// ID is the lease ID for the granted lease.
  	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
  	// TTL is the server chosen lease time-to-live in seconds.
  	TTL                  int64    `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
  	Error                string   `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseGrantResponse) Reset()         { *m = LeaseGrantResponse{} }
  func (m *LeaseGrantResponse) String() string { return proto.CompactTextString(m) }
  func (*LeaseGrantResponse) ProtoMessage()    {}
  func (*LeaseGrantResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{26}
  }
  func (m *LeaseGrantResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseGrantResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseGrantResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseGrantResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseGrantResponse.Merge(m, src)
  }
  func (m *LeaseGrantResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseGrantResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseGrantResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseGrantResponse proto.InternalMessageInfo
  
  func (m *LeaseGrantResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *LeaseGrantResponse) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *LeaseGrantResponse) GetTTL() int64 {
  	if m != nil {
  		return m.TTL
  	}
  	return 0
  }
  
  func (m *LeaseGrantResponse) GetError() string {
  	if m != nil {
  		return m.Error
  	}
  	return ""
  }
  
  type LeaseRevokeRequest struct {
  	// ID is the lease ID to revoke. When the ID is revoked, all associated keys will be deleted.
  	ID                   int64    `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseRevokeRequest) Reset()         { *m = LeaseRevokeRequest{} }
  func (m *LeaseRevokeRequest) String() string { return proto.CompactTextString(m) }
  func (*LeaseRevokeRequest) ProtoMessage()    {}
  func (*LeaseRevokeRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{27}
  }
  func (m *LeaseRevokeRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseRevokeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseRevokeRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseRevokeRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseRevokeRequest.Merge(m, src)
  }
  func (m *LeaseRevokeRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseRevokeRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseRevokeRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseRevokeRequest proto.InternalMessageInfo
  
  func (m *LeaseRevokeRequest) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  type LeaseRevokeResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *LeaseRevokeResponse) Reset()         { *m = LeaseRevokeResponse{} }
  func (m *LeaseRevokeResponse) String() string { return proto.CompactTextString(m) }
  func (*LeaseRevokeResponse) ProtoMessage()    {}
  func (*LeaseRevokeResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{28}
  }
  func (m *LeaseRevokeResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseRevokeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseRevokeResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseRevokeResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseRevokeResponse.Merge(m, src)
  }
  func (m *LeaseRevokeResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseRevokeResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseRevokeResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseRevokeResponse proto.InternalMessageInfo
  
  func (m *LeaseRevokeResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type LeaseCheckpoint struct {
  	// ID is the lease ID to checkpoint.
  	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	// Remaining_TTL is the remaining time until expiry of the lease.
  	Remaining_TTL        int64    `protobuf:"varint,2,opt,name=remaining_TTL,json=remainingTTL,proto3" json:"remaining_TTL,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseCheckpoint) Reset()         { *m = LeaseCheckpoint{} }
  func (m *LeaseCheckpoint) String() string { return proto.CompactTextString(m) }
  func (*LeaseCheckpoint) ProtoMessage()    {}
  func (*LeaseCheckpoint) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{29}
  }
  func (m *LeaseCheckpoint) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseCheckpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseCheckpoint.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseCheckpoint) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseCheckpoint.Merge(m, src)
  }
  func (m *LeaseCheckpoint) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseCheckpoint) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseCheckpoint.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseCheckpoint proto.InternalMessageInfo
  
  func (m *LeaseCheckpoint) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *LeaseCheckpoint) GetRemaining_TTL() int64 {
  	if m != nil {
  		return m.Remaining_TTL
  	}
  	return 0
  }
  
  type LeaseCheckpointRequest struct {
  	Checkpoints          []*LeaseCheckpoint `protobuf:"bytes,1,rep,name=checkpoints,proto3" json:"checkpoints,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
  	XXX_unrecognized     []byte             `json:"-"`
  	XXX_sizecache        int32              `json:"-"`
  }
  
  func (m *LeaseCheckpointRequest) Reset()         { *m = LeaseCheckpointRequest{} }
  func (m *LeaseCheckpointRequest) String() string { return proto.CompactTextString(m) }
  func (*LeaseCheckpointRequest) ProtoMessage()    {}
  func (*LeaseCheckpointRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{30}
  }
  func (m *LeaseCheckpointRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseCheckpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseCheckpointRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseCheckpointRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseCheckpointRequest.Merge(m, src)
  }
  func (m *LeaseCheckpointRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseCheckpointRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseCheckpointRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseCheckpointRequest proto.InternalMessageInfo
  
  func (m *LeaseCheckpointRequest) GetCheckpoints() []*LeaseCheckpoint {
  	if m != nil {
  		return m.Checkpoints
  	}
  	return nil
  }
  
  type LeaseCheckpointResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *LeaseCheckpointResponse) Reset()         { *m = LeaseCheckpointResponse{} }
  func (m *LeaseCheckpointResponse) String() string { return proto.CompactTextString(m) }
  func (*LeaseCheckpointResponse) ProtoMessage()    {}
  func (*LeaseCheckpointResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{31}
  }
  func (m *LeaseCheckpointResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseCheckpointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseCheckpointResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseCheckpointResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseCheckpointResponse.Merge(m, src)
  }
  func (m *LeaseCheckpointResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseCheckpointResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseCheckpointResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseCheckpointResponse proto.InternalMessageInfo
  
  func (m *LeaseCheckpointResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type LeaseKeepAliveRequest struct {
  	// ID is the lease ID for the lease to keep alive.
  	ID                   int64    `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseKeepAliveRequest) Reset()         { *m = LeaseKeepAliveRequest{} }
  func (m *LeaseKeepAliveRequest) String() string { return proto.CompactTextString(m) }
  func (*LeaseKeepAliveRequest) ProtoMessage()    {}
  func (*LeaseKeepAliveRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{32}
  }
  func (m *LeaseKeepAliveRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseKeepAliveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseKeepAliveRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseKeepAliveRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseKeepAliveRequest.Merge(m, src)
  }
  func (m *LeaseKeepAliveRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseKeepAliveRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseKeepAliveRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseKeepAliveRequest proto.InternalMessageInfo
  
  func (m *LeaseKeepAliveRequest) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  type LeaseKeepAliveResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// ID is the lease ID from the keep alive request.
  	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
  	// TTL is the new time-to-live for the lease.
  	TTL                  int64    `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseKeepAliveResponse) Reset()         { *m = LeaseKeepAliveResponse{} }
  func (m *LeaseKeepAliveResponse) String() string { return proto.CompactTextString(m) }
  func (*LeaseKeepAliveResponse) ProtoMessage()    {}
  func (*LeaseKeepAliveResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{33}
  }
  func (m *LeaseKeepAliveResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseKeepAliveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseKeepAliveResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseKeepAliveResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseKeepAliveResponse.Merge(m, src)
  }
  func (m *LeaseKeepAliveResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseKeepAliveResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseKeepAliveResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseKeepAliveResponse proto.InternalMessageInfo
  
  func (m *LeaseKeepAliveResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *LeaseKeepAliveResponse) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *LeaseKeepAliveResponse) GetTTL() int64 {
  	if m != nil {
  		return m.TTL
  	}
  	return 0
  }
  
  type LeaseTimeToLiveRequest struct {
  	// ID is the lease ID for the lease.
  	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	// keys is true to query all the keys attached to this lease.
  	Keys                 bool     `protobuf:"varint,2,opt,name=keys,proto3" json:"keys,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseTimeToLiveRequest) Reset()         { *m = LeaseTimeToLiveRequest{} }
  func (m *LeaseTimeToLiveRequest) String() string { return proto.CompactTextString(m) }
  func (*LeaseTimeToLiveRequest) ProtoMessage()    {}
  func (*LeaseTimeToLiveRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{34}
  }
  func (m *LeaseTimeToLiveRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseTimeToLiveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseTimeToLiveRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseTimeToLiveRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseTimeToLiveRequest.Merge(m, src)
  }
  func (m *LeaseTimeToLiveRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseTimeToLiveRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseTimeToLiveRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseTimeToLiveRequest proto.InternalMessageInfo
  
  func (m *LeaseTimeToLiveRequest) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *LeaseTimeToLiveRequest) GetKeys() bool {
  	if m != nil {
  		return m.Keys
  	}
  	return false
  }
  
  type LeaseTimeToLiveResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// ID is the lease ID from the keep alive request.
  	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
  	// TTL is the remaining TTL in seconds for the lease; the lease will expire in under TTL+1 seconds.
  	TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
  	// GrantedTTL is the initial granted time in seconds upon lease creation/renewal.
  	GrantedTTL int64 `protobuf:"varint,4,opt,name=grantedTTL,proto3" json:"grantedTTL,omitempty"`
  	// Keys is the list of keys attached to this lease.
  	Keys                 [][]byte `protobuf:"bytes,5,rep,name=keys,proto3" json:"keys,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseTimeToLiveResponse) Reset()         { *m = LeaseTimeToLiveResponse{} }
  func (m *LeaseTimeToLiveResponse) String() string { return proto.CompactTextString(m) }
  func (*LeaseTimeToLiveResponse) ProtoMessage()    {}
  func (*LeaseTimeToLiveResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{35}
  }
  func (m *LeaseTimeToLiveResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseTimeToLiveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseTimeToLiveResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseTimeToLiveResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseTimeToLiveResponse.Merge(m, src)
  }
  func (m *LeaseTimeToLiveResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseTimeToLiveResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseTimeToLiveResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseTimeToLiveResponse proto.InternalMessageInfo
  
  func (m *LeaseTimeToLiveResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *LeaseTimeToLiveResponse) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *LeaseTimeToLiveResponse) GetTTL() int64 {
  	if m != nil {
  		return m.TTL
  	}
  	return 0
  }
  
  func (m *LeaseTimeToLiveResponse) GetGrantedTTL() int64 {
  	if m != nil {
  		return m.GrantedTTL
  	}
  	return 0
  }
  
  func (m *LeaseTimeToLiveResponse) GetKeys() [][]byte {
  	if m != nil {
  		return m.Keys
  	}
  	return nil
  }
  
  type LeaseLeasesRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseLeasesRequest) Reset()         { *m = LeaseLeasesRequest{} }
  func (m *LeaseLeasesRequest) String() string { return proto.CompactTextString(m) }
  func (*LeaseLeasesRequest) ProtoMessage()    {}
  func (*LeaseLeasesRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{36}
  }
  func (m *LeaseLeasesRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseLeasesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseLeasesRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseLeasesRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseLeasesRequest.Merge(m, src)
  }
  func (m *LeaseLeasesRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseLeasesRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseLeasesRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseLeasesRequest proto.InternalMessageInfo
  
  type LeaseStatus struct {
  	ID                   int64    `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *LeaseStatus) Reset()         { *m = LeaseStatus{} }
  func (m *LeaseStatus) String() string { return proto.CompactTextString(m) }
  func (*LeaseStatus) ProtoMessage()    {}
  func (*LeaseStatus) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{37}
  }
  func (m *LeaseStatus) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseStatus.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseStatus) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseStatus.Merge(m, src)
  }
  func (m *LeaseStatus) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseStatus) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseStatus.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseStatus proto.InternalMessageInfo
  
  func (m *LeaseStatus) GetID() int64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  type LeaseLeasesResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	Leases               []*LeaseStatus  `protobuf:"bytes,2,rep,name=leases,proto3" json:"leases,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *LeaseLeasesResponse) Reset()         { *m = LeaseLeasesResponse{} }
  func (m *LeaseLeasesResponse) String() string { return proto.CompactTextString(m) }
  func (*LeaseLeasesResponse) ProtoMessage()    {}
  func (*LeaseLeasesResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{38}
  }
  func (m *LeaseLeasesResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *LeaseLeasesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_LeaseLeasesResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *LeaseLeasesResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_LeaseLeasesResponse.Merge(m, src)
  }
  func (m *LeaseLeasesResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *LeaseLeasesResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_LeaseLeasesResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_LeaseLeasesResponse proto.InternalMessageInfo
  
  func (m *LeaseLeasesResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *LeaseLeasesResponse) GetLeases() []*LeaseStatus {
  	if m != nil {
  		return m.Leases
  	}
  	return nil
  }
  
  type Member struct {
  	// ID is the member ID for this member.
  	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	// name is the human-readable name of the member. If the member is not started, the name will be an empty string.
  	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
  	// peerURLs is the list of URLs the member exposes to the cluster for communication.
  	PeerURLs []string `protobuf:"bytes,3,rep,name=peerURLs,proto3" json:"peerURLs,omitempty"`
  	// clientURLs is the list of URLs the member exposes to clients for communication. If the member is not started, clientURLs will be empty.
  	ClientURLs []string `protobuf:"bytes,4,rep,name=clientURLs,proto3" json:"clientURLs,omitempty"`
  	// isLearner indicates if the member is raft learner.
  	IsLearner            bool     `protobuf:"varint,5,opt,name=isLearner,proto3" json:"isLearner,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *Member) Reset()         { *m = Member{} }
  func (m *Member) String() string { return proto.CompactTextString(m) }
  func (*Member) ProtoMessage()    {}
  func (*Member) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{39}
  }
  func (m *Member) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_Member.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *Member) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_Member.Merge(m, src)
  }
  func (m *Member) XXX_Size() int {
  	return m.Size()
  }
  func (m *Member) XXX_DiscardUnknown() {
  	xxx_messageInfo_Member.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_Member proto.InternalMessageInfo
  
  func (m *Member) GetID() uint64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *Member) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  func (m *Member) GetPeerURLs() []string {
  	if m != nil {
  		return m.PeerURLs
  	}
  	return nil
  }
  
  func (m *Member) GetClientURLs() []string {
  	if m != nil {
  		return m.ClientURLs
  	}
  	return nil
  }
  
  func (m *Member) GetIsLearner() bool {
  	if m != nil {
  		return m.IsLearner
  	}
  	return false
  }
  
  type MemberAddRequest struct {
  	// peerURLs is the list of URLs the added member will use to communicate with the cluster.
  	PeerURLs []string `protobuf:"bytes,1,rep,name=peerURLs,proto3" json:"peerURLs,omitempty"`
  	// isLearner indicates if the added member is raft learner.
  	IsLearner            bool     `protobuf:"varint,2,opt,name=isLearner,proto3" json:"isLearner,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *MemberAddRequest) Reset()         { *m = MemberAddRequest{} }
  func (m *MemberAddRequest) String() string { return proto.CompactTextString(m) }
  func (*MemberAddRequest) ProtoMessage()    {}
  func (*MemberAddRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{40}
  }
  func (m *MemberAddRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberAddRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberAddRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberAddRequest.Merge(m, src)
  }
  func (m *MemberAddRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberAddRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberAddRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberAddRequest proto.InternalMessageInfo
  
  func (m *MemberAddRequest) GetPeerURLs() []string {
  	if m != nil {
  		return m.PeerURLs
  	}
  	return nil
  }
  
  func (m *MemberAddRequest) GetIsLearner() bool {
  	if m != nil {
  		return m.IsLearner
  	}
  	return false
  }
  
  type MemberAddResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// member is the member information for the added member.
  	Member *Member `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"`
  	// members is a list of all members after adding the new member.
  	Members              []*Member `protobuf:"bytes,3,rep,name=members,proto3" json:"members,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *MemberAddResponse) Reset()         { *m = MemberAddResponse{} }
  func (m *MemberAddResponse) String() string { return proto.CompactTextString(m) }
  func (*MemberAddResponse) ProtoMessage()    {}
  func (*MemberAddResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{41}
  }
  func (m *MemberAddResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberAddResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberAddResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberAddResponse.Merge(m, src)
  }
  func (m *MemberAddResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberAddResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberAddResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberAddResponse proto.InternalMessageInfo
  
  func (m *MemberAddResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *MemberAddResponse) GetMember() *Member {
  	if m != nil {
  		return m.Member
  	}
  	return nil
  }
  
  func (m *MemberAddResponse) GetMembers() []*Member {
  	if m != nil {
  		return m.Members
  	}
  	return nil
  }
  
  type MemberRemoveRequest struct {
  	// ID is the member ID of the member to remove.
  	ID                   uint64   `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *MemberRemoveRequest) Reset()         { *m = MemberRemoveRequest{} }
  func (m *MemberRemoveRequest) String() string { return proto.CompactTextString(m) }
  func (*MemberRemoveRequest) ProtoMessage()    {}
  func (*MemberRemoveRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{42}
  }
  func (m *MemberRemoveRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberRemoveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberRemoveRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberRemoveRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberRemoveRequest.Merge(m, src)
  }
  func (m *MemberRemoveRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberRemoveRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberRemoveRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberRemoveRequest proto.InternalMessageInfo
  
  func (m *MemberRemoveRequest) GetID() uint64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  type MemberRemoveResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// members is a list of all members after removing the member.
  	Members              []*Member `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *MemberRemoveResponse) Reset()         { *m = MemberRemoveResponse{} }
  func (m *MemberRemoveResponse) String() string { return proto.CompactTextString(m) }
  func (*MemberRemoveResponse) ProtoMessage()    {}
  func (*MemberRemoveResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{43}
  }
  func (m *MemberRemoveResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberRemoveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberRemoveResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberRemoveResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberRemoveResponse.Merge(m, src)
  }
  func (m *MemberRemoveResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberRemoveResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberRemoveResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberRemoveResponse proto.InternalMessageInfo
  
  func (m *MemberRemoveResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *MemberRemoveResponse) GetMembers() []*Member {
  	if m != nil {
  		return m.Members
  	}
  	return nil
  }
  
  type MemberUpdateRequest struct {
  	// ID is the member ID of the member to update.
  	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	// peerURLs is the new list of URLs the member will use to communicate with the cluster.
  	PeerURLs             []string `protobuf:"bytes,2,rep,name=peerURLs,proto3" json:"peerURLs,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *MemberUpdateRequest) Reset()         { *m = MemberUpdateRequest{} }
  func (m *MemberUpdateRequest) String() string { return proto.CompactTextString(m) }
  func (*MemberUpdateRequest) ProtoMessage()    {}
  func (*MemberUpdateRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{44}
  }
  func (m *MemberUpdateRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberUpdateRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberUpdateRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberUpdateRequest.Merge(m, src)
  }
  func (m *MemberUpdateRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberUpdateRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberUpdateRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberUpdateRequest proto.InternalMessageInfo
  
  func (m *MemberUpdateRequest) GetID() uint64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  func (m *MemberUpdateRequest) GetPeerURLs() []string {
  	if m != nil {
  		return m.PeerURLs
  	}
  	return nil
  }
  
  type MemberUpdateResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// members is a list of all members after updating the member.
  	Members              []*Member `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *MemberUpdateResponse) Reset()         { *m = MemberUpdateResponse{} }
  func (m *MemberUpdateResponse) String() string { return proto.CompactTextString(m) }
  func (*MemberUpdateResponse) ProtoMessage()    {}
  func (*MemberUpdateResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{45}
  }
  func (m *MemberUpdateResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberUpdateResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberUpdateResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberUpdateResponse.Merge(m, src)
  }
  func (m *MemberUpdateResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberUpdateResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberUpdateResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberUpdateResponse proto.InternalMessageInfo
  
  func (m *MemberUpdateResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *MemberUpdateResponse) GetMembers() []*Member {
  	if m != nil {
  		return m.Members
  	}
  	return nil
  }
  
  type MemberListRequest struct {
  	Linearizable         bool     `protobuf:"varint,1,opt,name=linearizable,proto3" json:"linearizable,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *MemberListRequest) Reset()         { *m = MemberListRequest{} }
  func (m *MemberListRequest) String() string { return proto.CompactTextString(m) }
  func (*MemberListRequest) ProtoMessage()    {}
  func (*MemberListRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{46}
  }
  func (m *MemberListRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberListRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberListRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberListRequest.Merge(m, src)
  }
  func (m *MemberListRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberListRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberListRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberListRequest proto.InternalMessageInfo
  
  func (m *MemberListRequest) GetLinearizable() bool {
  	if m != nil {
  		return m.Linearizable
  	}
  	return false
  }
  
  type MemberListResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// members is a list of all members associated with the cluster.
  	Members              []*Member `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *MemberListResponse) Reset()         { *m = MemberListResponse{} }
  func (m *MemberListResponse) String() string { return proto.CompactTextString(m) }
  func (*MemberListResponse) ProtoMessage()    {}
  func (*MemberListResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{47}
  }
  func (m *MemberListResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberListResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberListResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberListResponse.Merge(m, src)
  }
  func (m *MemberListResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberListResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberListResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberListResponse proto.InternalMessageInfo
  
  func (m *MemberListResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *MemberListResponse) GetMembers() []*Member {
  	if m != nil {
  		return m.Members
  	}
  	return nil
  }
  
  type MemberPromoteRequest struct {
  	// ID is the member ID of the member to promote.
  	ID                   uint64   `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *MemberPromoteRequest) Reset()         { *m = MemberPromoteRequest{} }
  func (m *MemberPromoteRequest) String() string { return proto.CompactTextString(m) }
  func (*MemberPromoteRequest) ProtoMessage()    {}
  func (*MemberPromoteRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{48}
  }
  func (m *MemberPromoteRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberPromoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberPromoteRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberPromoteRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberPromoteRequest.Merge(m, src)
  }
  func (m *MemberPromoteRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberPromoteRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberPromoteRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberPromoteRequest proto.InternalMessageInfo
  
  func (m *MemberPromoteRequest) GetID() uint64 {
  	if m != nil {
  		return m.ID
  	}
  	return 0
  }
  
  type MemberPromoteResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// members is a list of all members after promoting the member.
  	Members              []*Member `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *MemberPromoteResponse) Reset()         { *m = MemberPromoteResponse{} }
  func (m *MemberPromoteResponse) String() string { return proto.CompactTextString(m) }
  func (*MemberPromoteResponse) ProtoMessage()    {}
  func (*MemberPromoteResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{49}
  }
  func (m *MemberPromoteResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MemberPromoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MemberPromoteResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MemberPromoteResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MemberPromoteResponse.Merge(m, src)
  }
  func (m *MemberPromoteResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *MemberPromoteResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_MemberPromoteResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MemberPromoteResponse proto.InternalMessageInfo
  
  func (m *MemberPromoteResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *MemberPromoteResponse) GetMembers() []*Member {
  	if m != nil {
  		return m.Members
  	}
  	return nil
  }
  
  type DefragmentRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *DefragmentRequest) Reset()         { *m = DefragmentRequest{} }
  func (m *DefragmentRequest) String() string { return proto.CompactTextString(m) }
  func (*DefragmentRequest) ProtoMessage()    {}
  func (*DefragmentRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{50}
  }
  func (m *DefragmentRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DefragmentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DefragmentRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DefragmentRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DefragmentRequest.Merge(m, src)
  }
  func (m *DefragmentRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *DefragmentRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_DefragmentRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DefragmentRequest proto.InternalMessageInfo
  
  type DefragmentResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *DefragmentResponse) Reset()         { *m = DefragmentResponse{} }
  func (m *DefragmentResponse) String() string { return proto.CompactTextString(m) }
  func (*DefragmentResponse) ProtoMessage()    {}
  func (*DefragmentResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{51}
  }
  func (m *DefragmentResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DefragmentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DefragmentResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DefragmentResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DefragmentResponse.Merge(m, src)
  }
  func (m *DefragmentResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *DefragmentResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_DefragmentResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DefragmentResponse proto.InternalMessageInfo
  
  func (m *DefragmentResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type MoveLeaderRequest struct {
  	// targetID is the node ID for the new leader.
  	TargetID             uint64   `protobuf:"varint,1,opt,name=targetID,proto3" json:"targetID,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *MoveLeaderRequest) Reset()         { *m = MoveLeaderRequest{} }
  func (m *MoveLeaderRequest) String() string { return proto.CompactTextString(m) }
  func (*MoveLeaderRequest) ProtoMessage()    {}
  func (*MoveLeaderRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{52}
  }
  func (m *MoveLeaderRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MoveLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MoveLeaderRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MoveLeaderRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MoveLeaderRequest.Merge(m, src)
  }
  func (m *MoveLeaderRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *MoveLeaderRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_MoveLeaderRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MoveLeaderRequest proto.InternalMessageInfo
  
  func (m *MoveLeaderRequest) GetTargetID() uint64 {
  	if m != nil {
  		return m.TargetID
  	}
  	return 0
  }
  
  type MoveLeaderResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *MoveLeaderResponse) Reset()         { *m = MoveLeaderResponse{} }
  func (m *MoveLeaderResponse) String() string { return proto.CompactTextString(m) }
  func (*MoveLeaderResponse) ProtoMessage()    {}
  func (*MoveLeaderResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{53}
  }
  func (m *MoveLeaderResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *MoveLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_MoveLeaderResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *MoveLeaderResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_MoveLeaderResponse.Merge(m, src)
  }
  func (m *MoveLeaderResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *MoveLeaderResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_MoveLeaderResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_MoveLeaderResponse proto.InternalMessageInfo
  
  func (m *MoveLeaderResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AlarmRequest struct {
  	// action is the kind of alarm request to issue. The action
  	// may GET alarm statuses, ACTIVATE an alarm, or DEACTIVATE a
  	// raised alarm.
  	Action AlarmRequest_AlarmAction `protobuf:"varint,1,opt,name=action,proto3,enum=etcdserverpb.AlarmRequest_AlarmAction" json:"action,omitempty"`
  	// memberID is the ID of the member associated with the alarm. If memberID is 0, the
  	// alarm request covers all members.
  	MemberID uint64 `protobuf:"varint,2,opt,name=memberID,proto3" json:"memberID,omitempty"`
  	// alarm is the type of alarm to consider for this request.
  	Alarm                AlarmType `protobuf:"varint,3,opt,name=alarm,proto3,enum=etcdserverpb.AlarmType" json:"alarm,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *AlarmRequest) Reset()         { *m = AlarmRequest{} }
  func (m *AlarmRequest) String() string { return proto.CompactTextString(m) }
  func (*AlarmRequest) ProtoMessage()    {}
  func (*AlarmRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{54}
  }
  func (m *AlarmRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AlarmRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AlarmRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AlarmRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AlarmRequest.Merge(m, src)
  }
  func (m *AlarmRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AlarmRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AlarmRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AlarmRequest proto.InternalMessageInfo
  
  func (m *AlarmRequest) GetAction() AlarmRequest_AlarmAction {
  	if m != nil {
  		return m.Action
  	}
  	return AlarmRequest_GET
  }
  
  func (m *AlarmRequest) GetMemberID() uint64 {
  	if m != nil {
  		return m.MemberID
  	}
  	return 0
  }
  
  func (m *AlarmRequest) GetAlarm() AlarmType {
  	if m != nil {
  		return m.Alarm
  	}
  	return AlarmType_NONE
  }
  
  type AlarmMember struct {
  	// memberID is the ID of the member associated with the raised alarm.
  	MemberID uint64 `protobuf:"varint,1,opt,name=memberID,proto3" json:"memberID,omitempty"`
  	// alarm is the type of alarm which has been raised.
  	Alarm                AlarmType `protobuf:"varint,2,opt,name=alarm,proto3,enum=etcdserverpb.AlarmType" json:"alarm,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
  	XXX_unrecognized     []byte    `json:"-"`
  	XXX_sizecache        int32     `json:"-"`
  }
  
  func (m *AlarmMember) Reset()         { *m = AlarmMember{} }
  func (m *AlarmMember) String() string { return proto.CompactTextString(m) }
  func (*AlarmMember) ProtoMessage()    {}
  func (*AlarmMember) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{55}
  }
  func (m *AlarmMember) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AlarmMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AlarmMember.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AlarmMember) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AlarmMember.Merge(m, src)
  }
  func (m *AlarmMember) XXX_Size() int {
  	return m.Size()
  }
  func (m *AlarmMember) XXX_DiscardUnknown() {
  	xxx_messageInfo_AlarmMember.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AlarmMember proto.InternalMessageInfo
  
  func (m *AlarmMember) GetMemberID() uint64 {
  	if m != nil {
  		return m.MemberID
  	}
  	return 0
  }
  
  func (m *AlarmMember) GetAlarm() AlarmType {
  	if m != nil {
  		return m.Alarm
  	}
  	return AlarmType_NONE
  }
  
  type AlarmResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// alarms is a list of alarms associated with the alarm request.
  	Alarms               []*AlarmMember `protobuf:"bytes,2,rep,name=alarms,proto3" json:"alarms,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
  	XXX_unrecognized     []byte         `json:"-"`
  	XXX_sizecache        int32          `json:"-"`
  }
  
  func (m *AlarmResponse) Reset()         { *m = AlarmResponse{} }
  func (m *AlarmResponse) String() string { return proto.CompactTextString(m) }
  func (*AlarmResponse) ProtoMessage()    {}
  func (*AlarmResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{56}
  }
  func (m *AlarmResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AlarmResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AlarmResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AlarmResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AlarmResponse.Merge(m, src)
  }
  func (m *AlarmResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AlarmResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AlarmResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AlarmResponse proto.InternalMessageInfo
  
  func (m *AlarmResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AlarmResponse) GetAlarms() []*AlarmMember {
  	if m != nil {
  		return m.Alarms
  	}
  	return nil
  }
  
  type DowngradeRequest struct {
  	// action is the kind of downgrade request to issue. The action may
  	// VALIDATE the target version, DOWNGRADE the cluster version,
  	// or CANCEL the current downgrading job.
  	Action DowngradeRequest_DowngradeAction `protobuf:"varint,1,opt,name=action,proto3,enum=etcdserverpb.DowngradeRequest_DowngradeAction" json:"action,omitempty"`
  	// version is the target version to downgrade.
  	Version              string   `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *DowngradeRequest) Reset()         { *m = DowngradeRequest{} }
  func (m *DowngradeRequest) String() string { return proto.CompactTextString(m) }
  func (*DowngradeRequest) ProtoMessage()    {}
  func (*DowngradeRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{57}
  }
  func (m *DowngradeRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DowngradeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DowngradeRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DowngradeRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DowngradeRequest.Merge(m, src)
  }
  func (m *DowngradeRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *DowngradeRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_DowngradeRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DowngradeRequest proto.InternalMessageInfo
  
  func (m *DowngradeRequest) GetAction() DowngradeRequest_DowngradeAction {
  	if m != nil {
  		return m.Action
  	}
  	return DowngradeRequest_VALIDATE
  }
  
  func (m *DowngradeRequest) GetVersion() string {
  	if m != nil {
  		return m.Version
  	}
  	return ""
  }
  
  type DowngradeResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// version is the current cluster version.
  	Version              string   `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *DowngradeResponse) Reset()         { *m = DowngradeResponse{} }
  func (m *DowngradeResponse) String() string { return proto.CompactTextString(m) }
  func (*DowngradeResponse) ProtoMessage()    {}
  func (*DowngradeResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{58}
  }
  func (m *DowngradeResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DowngradeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DowngradeResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DowngradeResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DowngradeResponse.Merge(m, src)
  }
  func (m *DowngradeResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *DowngradeResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_DowngradeResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DowngradeResponse proto.InternalMessageInfo
  
  func (m *DowngradeResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *DowngradeResponse) GetVersion() string {
  	if m != nil {
  		return m.Version
  	}
  	return ""
  }
  
  // DowngradeVersionTestRequest is used for test only. The version in
  // this request will be read as the WAL record version.If the downgrade
  // target version is less than this version, then the downgrade(online)
  // or migration(offline) isn't safe, so shouldn't be allowed.
  type DowngradeVersionTestRequest struct {
  	Ver                  string   `protobuf:"bytes,1,opt,name=ver,proto3" json:"ver,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *DowngradeVersionTestRequest) Reset()         { *m = DowngradeVersionTestRequest{} }
  func (m *DowngradeVersionTestRequest) String() string { return proto.CompactTextString(m) }
  func (*DowngradeVersionTestRequest) ProtoMessage()    {}
  func (*DowngradeVersionTestRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{59}
  }
  func (m *DowngradeVersionTestRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DowngradeVersionTestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DowngradeVersionTestRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DowngradeVersionTestRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DowngradeVersionTestRequest.Merge(m, src)
  }
  func (m *DowngradeVersionTestRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *DowngradeVersionTestRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_DowngradeVersionTestRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DowngradeVersionTestRequest proto.InternalMessageInfo
  
  func (m *DowngradeVersionTestRequest) GetVer() string {
  	if m != nil {
  		return m.Ver
  	}
  	return ""
  }
  
  type StatusRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *StatusRequest) Reset()         { *m = StatusRequest{} }
  func (m *StatusRequest) String() string { return proto.CompactTextString(m) }
  func (*StatusRequest) ProtoMessage()    {}
  func (*StatusRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{60}
  }
  func (m *StatusRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_StatusRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *StatusRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_StatusRequest.Merge(m, src)
  }
  func (m *StatusRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *StatusRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_StatusRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_StatusRequest proto.InternalMessageInfo
  
  type StatusResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// version is the cluster protocol version used by the responding member.
  	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
  	// dbSize is the size of the backend database physically allocated, in bytes, of the responding member.
  	DbSize int64 `protobuf:"varint,3,opt,name=dbSize,proto3" json:"dbSize,omitempty"`
  	// leader is the member ID which the responding member believes is the current leader.
  	Leader uint64 `protobuf:"varint,4,opt,name=leader,proto3" json:"leader,omitempty"`
  	// raftIndex is the current raft committed index of the responding member.
  	RaftIndex uint64 `protobuf:"varint,5,opt,name=raftIndex,proto3" json:"raftIndex,omitempty"`
  	// raftTerm is the current raft term of the responding member.
  	RaftTerm uint64 `protobuf:"varint,6,opt,name=raftTerm,proto3" json:"raftTerm,omitempty"`
  	// raftAppliedIndex is the current raft applied index of the responding member.
  	RaftAppliedIndex uint64 `protobuf:"varint,7,opt,name=raftAppliedIndex,proto3" json:"raftAppliedIndex,omitempty"`
  	// errors contains alarm/health information and status.
  	Errors []string `protobuf:"bytes,8,rep,name=errors,proto3" json:"errors,omitempty"`
  	// dbSizeInUse is the size of the backend database logically in use, in bytes, of the responding member.
  	DbSizeInUse int64 `protobuf:"varint,9,opt,name=dbSizeInUse,proto3" json:"dbSizeInUse,omitempty"`
  	// isLearner indicates if the member is raft learner.
  	IsLearner bool `protobuf:"varint,10,opt,name=isLearner,proto3" json:"isLearner,omitempty"`
  	// storageVersion is the version of the db file. It might be updated with delay in relationship to the target cluster version.
  	StorageVersion string `protobuf:"bytes,11,opt,name=storageVersion,proto3" json:"storageVersion,omitempty"`
  	// dbSizeQuota is the configured etcd storage quota in bytes (the value passed to etcd instance by flag --quota-backend-bytes)
  	DbSizeQuota int64 `protobuf:"varint,12,opt,name=dbSizeQuota,proto3" json:"dbSizeQuota,omitempty"`
  	// downgradeInfo indicates if there is downgrade process.
  	DowngradeInfo        *DowngradeInfo `protobuf:"bytes,13,opt,name=downgradeInfo,proto3" json:"downgradeInfo,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
  	XXX_unrecognized     []byte         `json:"-"`
  	XXX_sizecache        int32          `json:"-"`
  }
  
  func (m *StatusResponse) Reset()         { *m = StatusResponse{} }
  func (m *StatusResponse) String() string { return proto.CompactTextString(m) }
  func (*StatusResponse) ProtoMessage()    {}
  func (*StatusResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{61}
  }
  func (m *StatusResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *StatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_StatusResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *StatusResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_StatusResponse.Merge(m, src)
  }
  func (m *StatusResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *StatusResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_StatusResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_StatusResponse proto.InternalMessageInfo
  
  func (m *StatusResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *StatusResponse) GetVersion() string {
  	if m != nil {
  		return m.Version
  	}
  	return ""
  }
  
  func (m *StatusResponse) GetDbSize() int64 {
  	if m != nil {
  		return m.DbSize
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetLeader() uint64 {
  	if m != nil {
  		return m.Leader
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetRaftIndex() uint64 {
  	if m != nil {
  		return m.RaftIndex
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetRaftTerm() uint64 {
  	if m != nil {
  		return m.RaftTerm
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetRaftAppliedIndex() uint64 {
  	if m != nil {
  		return m.RaftAppliedIndex
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetErrors() []string {
  	if m != nil {
  		return m.Errors
  	}
  	return nil
  }
  
  func (m *StatusResponse) GetDbSizeInUse() int64 {
  	if m != nil {
  		return m.DbSizeInUse
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetIsLearner() bool {
  	if m != nil {
  		return m.IsLearner
  	}
  	return false
  }
  
  func (m *StatusResponse) GetStorageVersion() string {
  	if m != nil {
  		return m.StorageVersion
  	}
  	return ""
  }
  
  func (m *StatusResponse) GetDbSizeQuota() int64 {
  	if m != nil {
  		return m.DbSizeQuota
  	}
  	return 0
  }
  
  func (m *StatusResponse) GetDowngradeInfo() *DowngradeInfo {
  	if m != nil {
  		return m.DowngradeInfo
  	}
  	return nil
  }
  
  type DowngradeInfo struct {
  	// enabled indicates whether the cluster is enabled to downgrade.
  	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
  	// targetVersion is the target downgrade version.
  	TargetVersion        string   `protobuf:"bytes,2,opt,name=targetVersion,proto3" json:"targetVersion,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *DowngradeInfo) Reset()         { *m = DowngradeInfo{} }
  func (m *DowngradeInfo) String() string { return proto.CompactTextString(m) }
  func (*DowngradeInfo) ProtoMessage()    {}
  func (*DowngradeInfo) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{62}
  }
  func (m *DowngradeInfo) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *DowngradeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_DowngradeInfo.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *DowngradeInfo) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_DowngradeInfo.Merge(m, src)
  }
  func (m *DowngradeInfo) XXX_Size() int {
  	return m.Size()
  }
  func (m *DowngradeInfo) XXX_DiscardUnknown() {
  	xxx_messageInfo_DowngradeInfo.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_DowngradeInfo proto.InternalMessageInfo
  
  func (m *DowngradeInfo) GetEnabled() bool {
  	if m != nil {
  		return m.Enabled
  	}
  	return false
  }
  
  func (m *DowngradeInfo) GetTargetVersion() string {
  	if m != nil {
  		return m.TargetVersion
  	}
  	return ""
  }
  
  type AuthEnableRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthEnableRequest) Reset()         { *m = AuthEnableRequest{} }
  func (m *AuthEnableRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthEnableRequest) ProtoMessage()    {}
  func (*AuthEnableRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{63}
  }
  func (m *AuthEnableRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthEnableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthEnableRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthEnableRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthEnableRequest.Merge(m, src)
  }
  func (m *AuthEnableRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthEnableRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthEnableRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthEnableRequest proto.InternalMessageInfo
  
  type AuthDisableRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthDisableRequest) Reset()         { *m = AuthDisableRequest{} }
  func (m *AuthDisableRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthDisableRequest) ProtoMessage()    {}
  func (*AuthDisableRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{64}
  }
  func (m *AuthDisableRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthDisableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthDisableRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthDisableRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthDisableRequest.Merge(m, src)
  }
  func (m *AuthDisableRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthDisableRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthDisableRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthDisableRequest proto.InternalMessageInfo
  
  type AuthStatusRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthStatusRequest) Reset()         { *m = AuthStatusRequest{} }
  func (m *AuthStatusRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthStatusRequest) ProtoMessage()    {}
  func (*AuthStatusRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{65}
  }
  func (m *AuthStatusRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthStatusRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthStatusRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthStatusRequest.Merge(m, src)
  }
  func (m *AuthStatusRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthStatusRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthStatusRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthStatusRequest proto.InternalMessageInfo
  
  type AuthenticateRequest struct {
  	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	Password             string   `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthenticateRequest) Reset()         { *m = AuthenticateRequest{} }
  func (m *AuthenticateRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthenticateRequest) ProtoMessage()    {}
  func (*AuthenticateRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{66}
  }
  func (m *AuthenticateRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthenticateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthenticateRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthenticateRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthenticateRequest.Merge(m, src)
  }
  func (m *AuthenticateRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthenticateRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthenticateRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthenticateRequest proto.InternalMessageInfo
  
  func (m *AuthenticateRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  func (m *AuthenticateRequest) GetPassword() string {
  	if m != nil {
  		return m.Password
  	}
  	return ""
  }
  
  type AuthUserAddRequest struct {
  	Name                 string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	Password             string                 `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
  	Options              *authpb.UserAddOptions `protobuf:"bytes,3,opt,name=options,proto3" json:"options,omitempty"`
  	HashedPassword       string                 `protobuf:"bytes,4,opt,name=hashedPassword,proto3" json:"hashedPassword,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
  	XXX_unrecognized     []byte                 `json:"-"`
  	XXX_sizecache        int32                  `json:"-"`
  }
  
  func (m *AuthUserAddRequest) Reset()         { *m = AuthUserAddRequest{} }
  func (m *AuthUserAddRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserAddRequest) ProtoMessage()    {}
  func (*AuthUserAddRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{67}
  }
  func (m *AuthUserAddRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserAddRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserAddRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserAddRequest.Merge(m, src)
  }
  func (m *AuthUserAddRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserAddRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserAddRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserAddRequest proto.InternalMessageInfo
  
  func (m *AuthUserAddRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  func (m *AuthUserAddRequest) GetPassword() string {
  	if m != nil {
  		return m.Password
  	}
  	return ""
  }
  
  func (m *AuthUserAddRequest) GetOptions() *authpb.UserAddOptions {
  	if m != nil {
  		return m.Options
  	}
  	return nil
  }
  
  func (m *AuthUserAddRequest) GetHashedPassword() string {
  	if m != nil {
  		return m.HashedPassword
  	}
  	return ""
  }
  
  type AuthUserGetRequest struct {
  	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthUserGetRequest) Reset()         { *m = AuthUserGetRequest{} }
  func (m *AuthUserGetRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserGetRequest) ProtoMessage()    {}
  func (*AuthUserGetRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{68}
  }
  func (m *AuthUserGetRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserGetRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserGetRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserGetRequest.Merge(m, src)
  }
  func (m *AuthUserGetRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserGetRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserGetRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserGetRequest proto.InternalMessageInfo
  
  func (m *AuthUserGetRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  type AuthUserDeleteRequest struct {
  	// name is the name of the user to delete.
  	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthUserDeleteRequest) Reset()         { *m = AuthUserDeleteRequest{} }
  func (m *AuthUserDeleteRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserDeleteRequest) ProtoMessage()    {}
  func (*AuthUserDeleteRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{69}
  }
  func (m *AuthUserDeleteRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserDeleteRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserDeleteRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserDeleteRequest.Merge(m, src)
  }
  func (m *AuthUserDeleteRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserDeleteRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserDeleteRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserDeleteRequest proto.InternalMessageInfo
  
  func (m *AuthUserDeleteRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  type AuthUserChangePasswordRequest struct {
  	// name is the name of the user whose password is being changed.
  	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	// password is the new password for the user. Note that this field will be removed in the API layer.
  	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
  	// hashedPassword is the new password for the user. Note that this field will be initialized in the API layer.
  	HashedPassword       string   `protobuf:"bytes,3,opt,name=hashedPassword,proto3" json:"hashedPassword,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthUserChangePasswordRequest) Reset()         { *m = AuthUserChangePasswordRequest{} }
  func (m *AuthUserChangePasswordRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserChangePasswordRequest) ProtoMessage()    {}
  func (*AuthUserChangePasswordRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{70}
  }
  func (m *AuthUserChangePasswordRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserChangePasswordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserChangePasswordRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserChangePasswordRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserChangePasswordRequest.Merge(m, src)
  }
  func (m *AuthUserChangePasswordRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserChangePasswordRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserChangePasswordRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserChangePasswordRequest proto.InternalMessageInfo
  
  func (m *AuthUserChangePasswordRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  func (m *AuthUserChangePasswordRequest) GetPassword() string {
  	if m != nil {
  		return m.Password
  	}
  	return ""
  }
  
  func (m *AuthUserChangePasswordRequest) GetHashedPassword() string {
  	if m != nil {
  		return m.HashedPassword
  	}
  	return ""
  }
  
  type AuthUserGrantRoleRequest struct {
  	// user is the name of the user which should be granted a given role.
  	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
  	// role is the name of the role to grant to the user.
  	Role                 string   `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthUserGrantRoleRequest) Reset()         { *m = AuthUserGrantRoleRequest{} }
  func (m *AuthUserGrantRoleRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserGrantRoleRequest) ProtoMessage()    {}
  func (*AuthUserGrantRoleRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{71}
  }
  func (m *AuthUserGrantRoleRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserGrantRoleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserGrantRoleRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserGrantRoleRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserGrantRoleRequest.Merge(m, src)
  }
  func (m *AuthUserGrantRoleRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserGrantRoleRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserGrantRoleRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserGrantRoleRequest proto.InternalMessageInfo
  
  func (m *AuthUserGrantRoleRequest) GetUser() string {
  	if m != nil {
  		return m.User
  	}
  	return ""
  }
  
  func (m *AuthUserGrantRoleRequest) GetRole() string {
  	if m != nil {
  		return m.Role
  	}
  	return ""
  }
  
  type AuthUserRevokeRoleRequest struct {
  	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	Role                 string   `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthUserRevokeRoleRequest) Reset()         { *m = AuthUserRevokeRoleRequest{} }
  func (m *AuthUserRevokeRoleRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserRevokeRoleRequest) ProtoMessage()    {}
  func (*AuthUserRevokeRoleRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{72}
  }
  func (m *AuthUserRevokeRoleRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserRevokeRoleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserRevokeRoleRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserRevokeRoleRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserRevokeRoleRequest.Merge(m, src)
  }
  func (m *AuthUserRevokeRoleRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserRevokeRoleRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserRevokeRoleRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserRevokeRoleRequest proto.InternalMessageInfo
  
  func (m *AuthUserRevokeRoleRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  func (m *AuthUserRevokeRoleRequest) GetRole() string {
  	if m != nil {
  		return m.Role
  	}
  	return ""
  }
  
  type AuthRoleAddRequest struct {
  	// name is the name of the role to add to the authentication system.
  	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthRoleAddRequest) Reset()         { *m = AuthRoleAddRequest{} }
  func (m *AuthRoleAddRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleAddRequest) ProtoMessage()    {}
  func (*AuthRoleAddRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{73}
  }
  func (m *AuthRoleAddRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleAddRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleAddRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleAddRequest.Merge(m, src)
  }
  func (m *AuthRoleAddRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleAddRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleAddRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleAddRequest proto.InternalMessageInfo
  
  func (m *AuthRoleAddRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  type AuthRoleGetRequest struct {
  	Role                 string   `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthRoleGetRequest) Reset()         { *m = AuthRoleGetRequest{} }
  func (m *AuthRoleGetRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleGetRequest) ProtoMessage()    {}
  func (*AuthRoleGetRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{74}
  }
  func (m *AuthRoleGetRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleGetRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleGetRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleGetRequest.Merge(m, src)
  }
  func (m *AuthRoleGetRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleGetRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleGetRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleGetRequest proto.InternalMessageInfo
  
  func (m *AuthRoleGetRequest) GetRole() string {
  	if m != nil {
  		return m.Role
  	}
  	return ""
  }
  
  type AuthUserListRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthUserListRequest) Reset()         { *m = AuthUserListRequest{} }
  func (m *AuthUserListRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthUserListRequest) ProtoMessage()    {}
  func (*AuthUserListRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{75}
  }
  func (m *AuthUserListRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserListRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserListRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserListRequest.Merge(m, src)
  }
  func (m *AuthUserListRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserListRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserListRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserListRequest proto.InternalMessageInfo
  
  type AuthRoleListRequest struct {
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthRoleListRequest) Reset()         { *m = AuthRoleListRequest{} }
  func (m *AuthRoleListRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleListRequest) ProtoMessage()    {}
  func (*AuthRoleListRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{76}
  }
  func (m *AuthRoleListRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleListRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleListRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleListRequest.Merge(m, src)
  }
  func (m *AuthRoleListRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleListRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleListRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleListRequest proto.InternalMessageInfo
  
  type AuthRoleDeleteRequest struct {
  	Role                 string   `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthRoleDeleteRequest) Reset()         { *m = AuthRoleDeleteRequest{} }
  func (m *AuthRoleDeleteRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleDeleteRequest) ProtoMessage()    {}
  func (*AuthRoleDeleteRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{77}
  }
  func (m *AuthRoleDeleteRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleDeleteRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleDeleteRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleDeleteRequest.Merge(m, src)
  }
  func (m *AuthRoleDeleteRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleDeleteRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleDeleteRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleDeleteRequest proto.InternalMessageInfo
  
  func (m *AuthRoleDeleteRequest) GetRole() string {
  	if m != nil {
  		return m.Role
  	}
  	return ""
  }
  
  type AuthRoleGrantPermissionRequest struct {
  	// name is the name of the role which will be granted the permission.
  	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  	// perm is the permission to grant to the role.
  	Perm                 *authpb.Permission `protobuf:"bytes,2,opt,name=perm,proto3" json:"perm,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
  	XXX_unrecognized     []byte             `json:"-"`
  	XXX_sizecache        int32              `json:"-"`
  }
  
  func (m *AuthRoleGrantPermissionRequest) Reset()         { *m = AuthRoleGrantPermissionRequest{} }
  func (m *AuthRoleGrantPermissionRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleGrantPermissionRequest) ProtoMessage()    {}
  func (*AuthRoleGrantPermissionRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{78}
  }
  func (m *AuthRoleGrantPermissionRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleGrantPermissionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleGrantPermissionRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleGrantPermissionRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleGrantPermissionRequest.Merge(m, src)
  }
  func (m *AuthRoleGrantPermissionRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleGrantPermissionRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleGrantPermissionRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleGrantPermissionRequest proto.InternalMessageInfo
  
  func (m *AuthRoleGrantPermissionRequest) GetName() string {
  	if m != nil {
  		return m.Name
  	}
  	return ""
  }
  
  func (m *AuthRoleGrantPermissionRequest) GetPerm() *authpb.Permission {
  	if m != nil {
  		return m.Perm
  	}
  	return nil
  }
  
  type AuthRoleRevokePermissionRequest struct {
  	Role                 string   `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
  	Key                  []byte   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
  	RangeEnd             []byte   `protobuf:"bytes,3,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthRoleRevokePermissionRequest) Reset()         { *m = AuthRoleRevokePermissionRequest{} }
  func (m *AuthRoleRevokePermissionRequest) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleRevokePermissionRequest) ProtoMessage()    {}
  func (*AuthRoleRevokePermissionRequest) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{79}
  }
  func (m *AuthRoleRevokePermissionRequest) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleRevokePermissionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleRevokePermissionRequest.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleRevokePermissionRequest) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleRevokePermissionRequest.Merge(m, src)
  }
  func (m *AuthRoleRevokePermissionRequest) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleRevokePermissionRequest) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleRevokePermissionRequest.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleRevokePermissionRequest proto.InternalMessageInfo
  
  func (m *AuthRoleRevokePermissionRequest) GetRole() string {
  	if m != nil {
  		return m.Role
  	}
  	return ""
  }
  
  func (m *AuthRoleRevokePermissionRequest) GetKey() []byte {
  	if m != nil {
  		return m.Key
  	}
  	return nil
  }
  
  func (m *AuthRoleRevokePermissionRequest) GetRangeEnd() []byte {
  	if m != nil {
  		return m.RangeEnd
  	}
  	return nil
  }
  
  type AuthEnableResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthEnableResponse) Reset()         { *m = AuthEnableResponse{} }
  func (m *AuthEnableResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthEnableResponse) ProtoMessage()    {}
  func (*AuthEnableResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{80}
  }
  func (m *AuthEnableResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthEnableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthEnableResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthEnableResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthEnableResponse.Merge(m, src)
  }
  func (m *AuthEnableResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthEnableResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthEnableResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthEnableResponse proto.InternalMessageInfo
  
  func (m *AuthEnableResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthDisableResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthDisableResponse) Reset()         { *m = AuthDisableResponse{} }
  func (m *AuthDisableResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthDisableResponse) ProtoMessage()    {}
  func (*AuthDisableResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{81}
  }
  func (m *AuthDisableResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthDisableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthDisableResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthDisableResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthDisableResponse.Merge(m, src)
  }
  func (m *AuthDisableResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthDisableResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthDisableResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthDisableResponse proto.InternalMessageInfo
  
  func (m *AuthDisableResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthStatusResponse struct {
  	Header  *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	Enabled bool            `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"`
  	// authRevision is the current revision of auth store
  	AuthRevision         uint64   `protobuf:"varint,3,opt,name=authRevision,proto3" json:"authRevision,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthStatusResponse) Reset()         { *m = AuthStatusResponse{} }
  func (m *AuthStatusResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthStatusResponse) ProtoMessage()    {}
  func (*AuthStatusResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{82}
  }
  func (m *AuthStatusResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthStatusResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthStatusResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthStatusResponse.Merge(m, src)
  }
  func (m *AuthStatusResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthStatusResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthStatusResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthStatusResponse proto.InternalMessageInfo
  
  func (m *AuthStatusResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AuthStatusResponse) GetEnabled() bool {
  	if m != nil {
  		return m.Enabled
  	}
  	return false
  }
  
  func (m *AuthStatusResponse) GetAuthRevision() uint64 {
  	if m != nil {
  		return m.AuthRevision
  	}
  	return 0
  }
  
  type AuthenticateResponse struct {
  	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	// token is an authorized token that can be used in succeeding RPCs
  	Token                string   `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
  	XXX_unrecognized     []byte   `json:"-"`
  	XXX_sizecache        int32    `json:"-"`
  }
  
  func (m *AuthenticateResponse) Reset()         { *m = AuthenticateResponse{} }
  func (m *AuthenticateResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthenticateResponse) ProtoMessage()    {}
  func (*AuthenticateResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{83}
  }
  func (m *AuthenticateResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthenticateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthenticateResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthenticateResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthenticateResponse.Merge(m, src)
  }
  func (m *AuthenticateResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthenticateResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthenticateResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthenticateResponse proto.InternalMessageInfo
  
  func (m *AuthenticateResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AuthenticateResponse) GetToken() string {
  	if m != nil {
  		return m.Token
  	}
  	return ""
  }
  
  type AuthUserAddResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserAddResponse) Reset()         { *m = AuthUserAddResponse{} }
  func (m *AuthUserAddResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserAddResponse) ProtoMessage()    {}
  func (*AuthUserAddResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{84}
  }
  func (m *AuthUserAddResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserAddResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserAddResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserAddResponse.Merge(m, src)
  }
  func (m *AuthUserAddResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserAddResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserAddResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserAddResponse proto.InternalMessageInfo
  
  func (m *AuthUserAddResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthUserGetResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	Roles                []string        `protobuf:"bytes,2,rep,name=roles,proto3" json:"roles,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserGetResponse) Reset()         { *m = AuthUserGetResponse{} }
  func (m *AuthUserGetResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserGetResponse) ProtoMessage()    {}
  func (*AuthUserGetResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{85}
  }
  func (m *AuthUserGetResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserGetResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserGetResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserGetResponse.Merge(m, src)
  }
  func (m *AuthUserGetResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserGetResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserGetResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserGetResponse proto.InternalMessageInfo
  
  func (m *AuthUserGetResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AuthUserGetResponse) GetRoles() []string {
  	if m != nil {
  		return m.Roles
  	}
  	return nil
  }
  
  type AuthUserDeleteResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserDeleteResponse) Reset()         { *m = AuthUserDeleteResponse{} }
  func (m *AuthUserDeleteResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserDeleteResponse) ProtoMessage()    {}
  func (*AuthUserDeleteResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{86}
  }
  func (m *AuthUserDeleteResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserDeleteResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserDeleteResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserDeleteResponse.Merge(m, src)
  }
  func (m *AuthUserDeleteResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserDeleteResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserDeleteResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserDeleteResponse proto.InternalMessageInfo
  
  func (m *AuthUserDeleteResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthUserChangePasswordResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserChangePasswordResponse) Reset()         { *m = AuthUserChangePasswordResponse{} }
  func (m *AuthUserChangePasswordResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserChangePasswordResponse) ProtoMessage()    {}
  func (*AuthUserChangePasswordResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{87}
  }
  func (m *AuthUserChangePasswordResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserChangePasswordResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserChangePasswordResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserChangePasswordResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserChangePasswordResponse.Merge(m, src)
  }
  func (m *AuthUserChangePasswordResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserChangePasswordResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserChangePasswordResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserChangePasswordResponse proto.InternalMessageInfo
  
  func (m *AuthUserChangePasswordResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthUserGrantRoleResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserGrantRoleResponse) Reset()         { *m = AuthUserGrantRoleResponse{} }
  func (m *AuthUserGrantRoleResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserGrantRoleResponse) ProtoMessage()    {}
  func (*AuthUserGrantRoleResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{88}
  }
  func (m *AuthUserGrantRoleResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserGrantRoleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserGrantRoleResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserGrantRoleResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserGrantRoleResponse.Merge(m, src)
  }
  func (m *AuthUserGrantRoleResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserGrantRoleResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserGrantRoleResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserGrantRoleResponse proto.InternalMessageInfo
  
  func (m *AuthUserGrantRoleResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthUserRevokeRoleResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserRevokeRoleResponse) Reset()         { *m = AuthUserRevokeRoleResponse{} }
  func (m *AuthUserRevokeRoleResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserRevokeRoleResponse) ProtoMessage()    {}
  func (*AuthUserRevokeRoleResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{89}
  }
  func (m *AuthUserRevokeRoleResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserRevokeRoleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserRevokeRoleResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserRevokeRoleResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserRevokeRoleResponse.Merge(m, src)
  }
  func (m *AuthUserRevokeRoleResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserRevokeRoleResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserRevokeRoleResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserRevokeRoleResponse proto.InternalMessageInfo
  
  func (m *AuthUserRevokeRoleResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthRoleAddResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthRoleAddResponse) Reset()         { *m = AuthRoleAddResponse{} }
  func (m *AuthRoleAddResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleAddResponse) ProtoMessage()    {}
  func (*AuthRoleAddResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{90}
  }
  func (m *AuthRoleAddResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleAddResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleAddResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleAddResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleAddResponse.Merge(m, src)
  }
  func (m *AuthRoleAddResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleAddResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleAddResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleAddResponse proto.InternalMessageInfo
  
  func (m *AuthRoleAddResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthRoleGetResponse struct {
  	Header               *ResponseHeader      `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	Perm                 []*authpb.Permission `protobuf:"bytes,2,rep,name=perm,proto3" json:"perm,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
  	XXX_unrecognized     []byte               `json:"-"`
  	XXX_sizecache        int32                `json:"-"`
  }
  
  func (m *AuthRoleGetResponse) Reset()         { *m = AuthRoleGetResponse{} }
  func (m *AuthRoleGetResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleGetResponse) ProtoMessage()    {}
  func (*AuthRoleGetResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{91}
  }
  func (m *AuthRoleGetResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleGetResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleGetResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleGetResponse.Merge(m, src)
  }
  func (m *AuthRoleGetResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleGetResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleGetResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleGetResponse proto.InternalMessageInfo
  
  func (m *AuthRoleGetResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AuthRoleGetResponse) GetPerm() []*authpb.Permission {
  	if m != nil {
  		return m.Perm
  	}
  	return nil
  }
  
  type AuthRoleListResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	Roles                []string        `protobuf:"bytes,2,rep,name=roles,proto3" json:"roles,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthRoleListResponse) Reset()         { *m = AuthRoleListResponse{} }
  func (m *AuthRoleListResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleListResponse) ProtoMessage()    {}
  func (*AuthRoleListResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{92}
  }
  func (m *AuthRoleListResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleListResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleListResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleListResponse.Merge(m, src)
  }
  func (m *AuthRoleListResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleListResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleListResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleListResponse proto.InternalMessageInfo
  
  func (m *AuthRoleListResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AuthRoleListResponse) GetRoles() []string {
  	if m != nil {
  		return m.Roles
  	}
  	return nil
  }
  
  type AuthUserListResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	Users                []string        `protobuf:"bytes,2,rep,name=users,proto3" json:"users,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthUserListResponse) Reset()         { *m = AuthUserListResponse{} }
  func (m *AuthUserListResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthUserListResponse) ProtoMessage()    {}
  func (*AuthUserListResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{93}
  }
  func (m *AuthUserListResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthUserListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthUserListResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthUserListResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthUserListResponse.Merge(m, src)
  }
  func (m *AuthUserListResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthUserListResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthUserListResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthUserListResponse proto.InternalMessageInfo
  
  func (m *AuthUserListResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func (m *AuthUserListResponse) GetUsers() []string {
  	if m != nil {
  		return m.Users
  	}
  	return nil
  }
  
  type AuthRoleDeleteResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthRoleDeleteResponse) Reset()         { *m = AuthRoleDeleteResponse{} }
  func (m *AuthRoleDeleteResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleDeleteResponse) ProtoMessage()    {}
  func (*AuthRoleDeleteResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{94}
  }
  func (m *AuthRoleDeleteResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleDeleteResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleDeleteResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleDeleteResponse.Merge(m, src)
  }
  func (m *AuthRoleDeleteResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleDeleteResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleDeleteResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleDeleteResponse proto.InternalMessageInfo
  
  func (m *AuthRoleDeleteResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthRoleGrantPermissionResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthRoleGrantPermissionResponse) Reset()         { *m = AuthRoleGrantPermissionResponse{} }
  func (m *AuthRoleGrantPermissionResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleGrantPermissionResponse) ProtoMessage()    {}
  func (*AuthRoleGrantPermissionResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{95}
  }
  func (m *AuthRoleGrantPermissionResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleGrantPermissionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleGrantPermissionResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleGrantPermissionResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleGrantPermissionResponse.Merge(m, src)
  }
  func (m *AuthRoleGrantPermissionResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleGrantPermissionResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleGrantPermissionResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleGrantPermissionResponse proto.InternalMessageInfo
  
  func (m *AuthRoleGrantPermissionResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  type AuthRoleRevokePermissionResponse struct {
  	Header               *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
  	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
  	XXX_unrecognized     []byte          `json:"-"`
  	XXX_sizecache        int32           `json:"-"`
  }
  
  func (m *AuthRoleRevokePermissionResponse) Reset()         { *m = AuthRoleRevokePermissionResponse{} }
  func (m *AuthRoleRevokePermissionResponse) String() string { return proto.CompactTextString(m) }
  func (*AuthRoleRevokePermissionResponse) ProtoMessage()    {}
  func (*AuthRoleRevokePermissionResponse) Descriptor() ([]byte, []int) {
  	return fileDescriptor_77a6da22d6a3feb1, []int{96}
  }
  func (m *AuthRoleRevokePermissionResponse) XXX_Unmarshal(b []byte) error {
  	return m.Unmarshal(b)
  }
  func (m *AuthRoleRevokePermissionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  	if deterministic {
  		return xxx_messageInfo_AuthRoleRevokePermissionResponse.Marshal(b, m, deterministic)
  	} else {
  		b = b[:cap(b)]
  		n, err := m.MarshalToSizedBuffer(b)
  		if err != nil {
  			return nil, err
  		}
  		return b[:n], nil
  	}
  }
  func (m *AuthRoleRevokePermissionResponse) XXX_Merge(src proto.Message) {
  	xxx_messageInfo_AuthRoleRevokePermissionResponse.Merge(m, src)
  }
  func (m *AuthRoleRevokePermissionResponse) XXX_Size() int {
  	return m.Size()
  }
  func (m *AuthRoleRevokePermissionResponse) XXX_DiscardUnknown() {
  	xxx_messageInfo_AuthRoleRevokePermissionResponse.DiscardUnknown(m)
  }
  
  var xxx_messageInfo_AuthRoleRevokePermissionResponse proto.InternalMessageInfo
  
  func (m *AuthRoleRevokePermissionResponse) GetHeader() *ResponseHeader {
  	if m != nil {
  		return m.Header
  	}
  	return nil
  }
  
  func init() {
  	proto.RegisterEnum("etcdserverpb.AlarmType", AlarmType_name, AlarmType_value)
  	proto.RegisterEnum("etcdserverpb.RangeRequest_SortOrder", RangeRequest_SortOrder_name, RangeRequest_SortOrder_value)
  	proto.RegisterEnum("etcdserverpb.RangeRequest_SortTarget", RangeRequest_SortTarget_name, RangeRequest_SortTarget_value)
  	proto.RegisterEnum("etcdserverpb.Compare_CompareResult", Compare_CompareResult_name, Compare_CompareResult_value)
  	proto.RegisterEnum("etcdserverpb.Compare_CompareTarget", Compare_CompareTarget_name, Compare_CompareTarget_value)
  	proto.RegisterEnum("etcdserverpb.WatchCreateRequest_FilterType", WatchCreateRequest_FilterType_name, WatchCreateRequest_FilterType_value)
  	proto.RegisterEnum("etcdserverpb.AlarmRequest_AlarmAction", AlarmRequest_AlarmAction_name, AlarmRequest_AlarmAction_value)
  	proto.RegisterEnum("etcdserverpb.DowngradeRequest_DowngradeAction", DowngradeRequest_DowngradeAction_name, DowngradeRequest_DowngradeAction_value)
  	proto.RegisterType((*ResponseHeader)(nil), "etcdserverpb.ResponseHeader")
  	proto.RegisterType((*RangeRequest)(nil), "etcdserverpb.RangeRequest")
  	proto.RegisterType((*RangeResponse)(nil), "etcdserverpb.RangeResponse")
  	proto.RegisterType((*PutRequest)(nil), "etcdserverpb.PutRequest")
  	proto.RegisterType((*PutResponse)(nil), "etcdserverpb.PutResponse")
  	proto.RegisterType((*DeleteRangeRequest)(nil), "etcdserverpb.DeleteRangeRequest")
  	proto.RegisterType((*DeleteRangeResponse)(nil), "etcdserverpb.DeleteRangeResponse")
  	proto.RegisterType((*RequestOp)(nil), "etcdserverpb.RequestOp")
  	proto.RegisterType((*ResponseOp)(nil), "etcdserverpb.ResponseOp")
  	proto.RegisterType((*Compare)(nil), "etcdserverpb.Compare")
  	proto.RegisterType((*TxnRequest)(nil), "etcdserverpb.TxnRequest")
  	proto.RegisterType((*TxnResponse)(nil), "etcdserverpb.TxnResponse")
  	proto.RegisterType((*CompactionRequest)(nil), "etcdserverpb.CompactionRequest")
  	proto.RegisterType((*CompactionResponse)(nil), "etcdserverpb.CompactionResponse")
  	proto.RegisterType((*HashRequest)(nil), "etcdserverpb.HashRequest")
  	proto.RegisterType((*HashKVRequest)(nil), "etcdserverpb.HashKVRequest")
  	proto.RegisterType((*HashKVResponse)(nil), "etcdserverpb.HashKVResponse")
  	proto.RegisterType((*HashResponse)(nil), "etcdserverpb.HashResponse")
  	proto.RegisterType((*SnapshotRequest)(nil), "etcdserverpb.SnapshotRequest")
  	proto.RegisterType((*SnapshotResponse)(nil), "etcdserverpb.SnapshotResponse")
  	proto.RegisterType((*WatchRequest)(nil), "etcdserverpb.WatchRequest")
  	proto.RegisterType((*WatchCreateRequest)(nil), "etcdserverpb.WatchCreateRequest")
  	proto.RegisterType((*WatchCancelRequest)(nil), "etcdserverpb.WatchCancelRequest")
  	proto.RegisterType((*WatchProgressRequest)(nil), "etcdserverpb.WatchProgressRequest")
  	proto.RegisterType((*WatchResponse)(nil), "etcdserverpb.WatchResponse")
  	proto.RegisterType((*LeaseGrantRequest)(nil), "etcdserverpb.LeaseGrantRequest")
  	proto.RegisterType((*LeaseGrantResponse)(nil), "etcdserverpb.LeaseGrantResponse")
  	proto.RegisterType((*LeaseRevokeRequest)(nil), "etcdserverpb.LeaseRevokeRequest")
  	proto.RegisterType((*LeaseRevokeResponse)(nil), "etcdserverpb.LeaseRevokeResponse")
  	proto.RegisterType((*LeaseCheckpoint)(nil), "etcdserverpb.LeaseCheckpoint")
  	proto.RegisterType((*LeaseCheckpointRequest)(nil), "etcdserverpb.LeaseCheckpointRequest")
  	proto.RegisterType((*LeaseCheckpointResponse)(nil), "etcdserverpb.LeaseCheckpointResponse")
  	proto.RegisterType((*LeaseKeepAliveRequest)(nil), "etcdserverpb.LeaseKeepAliveRequest")
  	proto.RegisterType((*LeaseKeepAliveResponse)(nil), "etcdserverpb.LeaseKeepAliveResponse")
  	proto.RegisterType((*LeaseTimeToLiveRequest)(nil), "etcdserverpb.LeaseTimeToLiveRequest")
  	proto.RegisterType((*LeaseTimeToLiveResponse)(nil), "etcdserverpb.LeaseTimeToLiveResponse")
  	proto.RegisterType((*LeaseLeasesRequest)(nil), "etcdserverpb.LeaseLeasesRequest")
  	proto.RegisterType((*LeaseStatus)(nil), "etcdserverpb.LeaseStatus")
  	proto.RegisterType((*LeaseLeasesResponse)(nil), "etcdserverpb.LeaseLeasesResponse")
  	proto.RegisterType((*Member)(nil), "etcdserverpb.Member")
  	proto.RegisterType((*MemberAddRequest)(nil), "etcdserverpb.MemberAddRequest")
  	proto.RegisterType((*MemberAddResponse)(nil), "etcdserverpb.MemberAddResponse")
  	proto.RegisterType((*MemberRemoveRequest)(nil), "etcdserverpb.MemberRemoveRequest")
  	proto.RegisterType((*MemberRemoveResponse)(nil), "etcdserverpb.MemberRemoveResponse")
  	proto.RegisterType((*MemberUpdateRequest)(nil), "etcdserverpb.MemberUpdateRequest")
  	proto.RegisterType((*MemberUpdateResponse)(nil), "etcdserverpb.MemberUpdateResponse")
  	proto.RegisterType((*MemberListRequest)(nil), "etcdserverpb.MemberListRequest")
  	proto.RegisterType((*MemberListResponse)(nil), "etcdserverpb.MemberListResponse")
  	proto.RegisterType((*MemberPromoteRequest)(nil), "etcdserverpb.MemberPromoteRequest")
  	proto.RegisterType((*MemberPromoteResponse)(nil), "etcdserverpb.MemberPromoteResponse")
  	proto.RegisterType((*DefragmentRequest)(nil), "etcdserverpb.DefragmentRequest")
  	proto.RegisterType((*DefragmentResponse)(nil), "etcdserverpb.DefragmentResponse")
  	proto.RegisterType((*MoveLeaderRequest)(nil), "etcdserverpb.MoveLeaderRequest")
  	proto.RegisterType((*MoveLeaderResponse)(nil), "etcdserverpb.MoveLeaderResponse")
  	proto.RegisterType((*AlarmRequest)(nil), "etcdserverpb.AlarmRequest")
  	proto.RegisterType((*AlarmMember)(nil), "etcdserverpb.AlarmMember")
  	proto.RegisterType((*AlarmResponse)(nil), "etcdserverpb.AlarmResponse")
  	proto.RegisterType((*DowngradeRequest)(nil), "etcdserverpb.DowngradeRequest")
  	proto.RegisterType((*DowngradeResponse)(nil), "etcdserverpb.DowngradeResponse")
  	proto.RegisterType((*DowngradeVersionTestRequest)(nil), "etcdserverpb.DowngradeVersionTestRequest")
  	proto.RegisterType((*StatusRequest)(nil), "etcdserverpb.StatusRequest")
  	proto.RegisterType((*StatusResponse)(nil), "etcdserverpb.StatusResponse")
  	proto.RegisterType((*DowngradeInfo)(nil), "etcdserverpb.DowngradeInfo")
  	proto.RegisterType((*AuthEnableRequest)(nil), "etcdserverpb.AuthEnableRequest")
  	proto.RegisterType((*AuthDisableRequest)(nil), "etcdserverpb.AuthDisableRequest")
  	proto.RegisterType((*AuthStatusRequest)(nil), "etcdserverpb.AuthStatusRequest")
  	proto.RegisterType((*AuthenticateRequest)(nil), "etcdserverpb.AuthenticateRequest")
  	proto.RegisterType((*AuthUserAddRequest)(nil), "etcdserverpb.AuthUserAddRequest")
  	proto.RegisterType((*AuthUserGetRequest)(nil), "etcdserverpb.AuthUserGetRequest")
  	proto.RegisterType((*AuthUserDeleteRequest)(nil), "etcdserverpb.AuthUserDeleteRequest")
  	proto.RegisterType((*AuthUserChangePasswordRequest)(nil), "etcdserverpb.AuthUserChangePasswordRequest")
  	proto.RegisterType((*AuthUserGrantRoleRequest)(nil), "etcdserverpb.AuthUserGrantRoleRequest")
  	proto.RegisterType((*AuthUserRevokeRoleRequest)(nil), "etcdserverpb.AuthUserRevokeRoleRequest")
  	proto.RegisterType((*AuthRoleAddRequest)(nil), "etcdserverpb.AuthRoleAddRequest")
  	proto.RegisterType((*AuthRoleGetRequest)(nil), "etcdserverpb.AuthRoleGetRequest")
  	proto.RegisterType((*AuthUserListRequest)(nil), "etcdserverpb.AuthUserListRequest")
  	proto.RegisterType((*AuthRoleListRequest)(nil), "etcdserverpb.AuthRoleListRequest")
  	proto.RegisterType((*AuthRoleDeleteRequest)(nil), "etcdserverpb.AuthRoleDeleteRequest")
  	proto.RegisterType((*AuthRoleGrantPermissionRequest)(nil), "etcdserverpb.AuthRoleGrantPermissionRequest")
  	proto.RegisterType((*AuthRoleRevokePermissionRequest)(nil), "etcdserverpb.AuthRoleRevokePermissionRequest")
  	proto.RegisterType((*AuthEnableResponse)(nil), "etcdserverpb.AuthEnableResponse")
  	proto.RegisterType((*AuthDisableResponse)(nil), "etcdserverpb.AuthDisableResponse")
  	proto.RegisterType((*AuthStatusResponse)(nil), "etcdserverpb.AuthStatusResponse")
  	proto.RegisterType((*AuthenticateResponse)(nil), "etcdserverpb.AuthenticateResponse")
  	proto.RegisterType((*AuthUserAddResponse)(nil), "etcdserverpb.AuthUserAddResponse")
  	proto.RegisterType((*AuthUserGetResponse)(nil), "etcdserverpb.AuthUserGetResponse")
  	proto.RegisterType((*AuthUserDeleteResponse)(nil), "etcdserverpb.AuthUserDeleteResponse")
  	proto.RegisterType((*AuthUserChangePasswordResponse)(nil), "etcdserverpb.AuthUserChangePasswordResponse")
  	proto.RegisterType((*AuthUserGrantRoleResponse)(nil), "etcdserverpb.AuthUserGrantRoleResponse")
  	proto.RegisterType((*AuthUserRevokeRoleResponse)(nil), "etcdserverpb.AuthUserRevokeRoleResponse")
  	proto.RegisterType((*AuthRoleAddResponse)(nil), "etcdserverpb.AuthRoleAddResponse")
  	proto.RegisterType((*AuthRoleGetResponse)(nil), "etcdserverpb.AuthRoleGetResponse")
  	proto.RegisterType((*AuthRoleListResponse)(nil), "etcdserverpb.AuthRoleListResponse")
  	proto.RegisterType((*AuthUserListResponse)(nil), "etcdserverpb.AuthUserListResponse")
  	proto.RegisterType((*AuthRoleDeleteResponse)(nil), "etcdserverpb.AuthRoleDeleteResponse")
  	proto.RegisterType((*AuthRoleGrantPermissionResponse)(nil), "etcdserverpb.AuthRoleGrantPermissionResponse")
  	proto.RegisterType((*AuthRoleRevokePermissionResponse)(nil), "etcdserverpb.AuthRoleRevokePermissionResponse")
  }
  
  func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
  
  var fileDescriptor_77a6da22d6a3feb1 = []byte{
  	// 4564 bytes of a gzipped FileDescriptorProto
  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3c, 0x5d, 0x6f, 0x5c, 0x49,
  	0x56, 0xbe, 0xdd, 0xb6, 0xdb, 0x7d, 0xfa, 0xc3, 0x9d, 0x8a, 0x93, 0x74, 0x3a, 0x89, 0xe3, 0xb9,
  	0x49, 0x66, 0x32, 0x99, 0x89, 0x3b, 0xb1, 0x93, 0x99, 0x25, 0x68, 0x86, 0xed, 0xd8, 0x3d, 0x89,
  	0x37, 0x8e, 0xed, 0xb9, 0xee, 0x64, 0x76, 0x82, 0xb4, 0xe6, 0xba, 0xbb, 0x62, 0xdf, 0x75, 0xf7,
  	0xbd, 0xbd, 0xf7, 0x5e, 0x77, 0xec, 0xe1, 0x61, 0x87, 0x85, 0x65, 0xb5, 0x20, 0xad, 0xc4, 0x20,
  	0xa1, 0x15, 0x82, 0x17, 0x40, 0x82, 0x07, 0x40, 0xf0, 0xc0, 0x03, 0x02, 0x89, 0x07, 0x78, 0x80,
  	0x07, 0x24, 0x24, 0xfe, 0x00, 0x0c, 0xfb, 0xc4, 0xaf, 0x58, 0xd5, 0xd7, 0xad, 0xaa, 0xfb, 0x61,
  	0x67, 0xd6, 0x1e, 0xed, 0x4b, 0x7c, 0xab, 0xea, 0x7c, 0xd5, 0x39, 0x55, 0xe7, 0x54, 0x9d, 0x53,
  	0x69, 0x28, 0xfa, 0xc3, 0xee, 0xfc, 0xd0, 0xf7, 0x42, 0x0f, 0x95, 0x71, 0xd8, 0xed, 0x05, 0xd8,
  	0x1f, 0x61, 0x7f, 0xb8, 0xdd, 0xa8, 0x93, 0x56, 0xd3, 0x1e, 0x3a, 0xcd, 0xc1, 0xa8, 0xdb, 0x1d,
  	0x6e, 0x37, 0xf7, 0x46, 0x0c, 0xae, 0xd1, 0x88, 0x46, 0xec, 0xfd, 0x70, 0x77, 0xb8, 0x4d, 0xff,
  	0xf0, 0xb1, 0xb9, 0x68, 0x6c, 0x84, 0xfd, 0xc0, 0xf1, 0xdc, 0xe1, 0xb6, 0xf8, 0xe2, 0x10, 0x97,
  	0x77, 0x3c, 0x6f, 0xa7, 0x8f, 0x19, 0xbe, 0xeb, 0x7a, 0xa1, 0x1d, 0x3a, 0x9e, 0x1b, 0xf0, 0x51,
  	0xf6, 0xa7, 0x7b, 0x7b, 0x07, 0xbb, 0xb7, 0xbd, 0x21, 0x76, 0xed, 0xa1, 0x33, 0x5a, 0x68, 0x7a,
  	0x43, 0x0a, 0x93, 0x84, 0x37, 0x7f, 0x62, 0x40, 0xd5, 0xc2, 0xc1, 0xd0, 0x73, 0x03, 0xfc, 0x18,
  	0xdb, 0x3d, 0xec, 0xa3, 0x2b, 0x00, 0xdd, 0xfe, 0x7e, 0x10, 0x62, 0x7f, 0xcb, 0xe9, 0xd5, 0x8d,
  	0x39, 0xe3, 0xe6, 0xb8, 0x55, 0xe4, 0x3d, 0x2b, 0x3d, 0x74, 0x09, 0x8a, 0x03, 0x3c, 0xd8, 0x66,
  	0xa3, 0x39, 0x3a, 0x3a, 0xc5, 0x3a, 0x56, 0x7a, 0xa8, 0x01, 0x53, 0x3e, 0x1e, 0x39, 0x44, 0xdc,
  	0x7a, 0x7e, 0xce, 0xb8, 0x99, 0xb7, 0xa2, 0x36, 0x41, 0xf4, 0xed, 0x97, 0xe1, 0x56, 0x88, 0xfd,
  	0x41, 0x7d, 0x9c, 0x21, 0x92, 0x8e, 0x0e, 0xf6, 0x07, 0x0f, 0x0a, 0x3f, 0xf8, 0x87, 0x7a, 0x7e,
  	0x71, 0xfe, 0x8e, 0xf9, 0xaf, 0x13, 0x50, 0xb6, 0x6c, 0x77, 0x07, 0x5b, 0xf8, 0x7b, 0xfb, 0x38,
  	0x08, 0x51, 0x0d, 0xf2, 0x7b, 0xf8, 0x90, 0xca, 0x51, 0xb6, 0xc8, 0x27, 0x23, 0xe4, 0xee, 0xe0,
  	0x2d, 0xec, 0x32, 0x09, 0xca, 0x84, 0x90, 0xbb, 0x83, 0xdb, 0x6e, 0x0f, 0xcd, 0xc0, 0x44, 0xdf,
  	0x19, 0x38, 0x21, 0x67, 0xcf, 0x1a, 0x9a, 0x5c, 0xe3, 0x31, 0xb9, 0x96, 0x00, 0x02, 0xcf, 0x0f,
  	0xb7, 0x3c, 0xbf, 0x87, 0xfd, 0xfa, 0xc4, 0x9c, 0x71, 0xb3, 0xba, 0x70, 0x7d, 0x5e, 0xb5, 0xe5,
  	0xbc, 0x2a, 0xd0, 0xfc, 0xa6, 0xe7, 0x87, 0xeb, 0x04, 0xd6, 0x2a, 0x06, 0xe2, 0x13, 0x7d, 0x04,
  	0x25, 0x4a, 0x24, 0xb4, 0xfd, 0x1d, 0x1c, 0xd6, 0x27, 0x29, 0x95, 0x1b, 0xc7, 0x50, 0xe9, 0x50,
  	0x60, 0x8b, 0xb2, 0x67, 0xdf, 0xc8, 0x84, 0x72, 0x80, 0x7d, 0xc7, 0xee, 0x3b, 0x9f, 0xd9, 0xdb,
  	0x7d, 0x5c, 0x2f, 0xcc, 0x19, 0x37, 0xa7, 0x2c, 0xad, 0x8f, 0xcc, 0x7f, 0x0f, 0x1f, 0x06, 0x5b,
  	0x9e, 0xdb, 0x3f, 0xac, 0x4f, 0x51, 0x80, 0x29, 0xd2, 0xb1, 0xee, 0xf6, 0x0f, 0xa9, 0xf5, 0xbc,
  	0x7d, 0x37, 0x64, 0xa3, 0x45, 0x3a, 0x5a, 0xa4, 0x3d, 0x74, 0xf8, 0x2e, 0xd4, 0x06, 0x8e, 0xbb,
  	0x35, 0xf0, 0x7a, 0x5b, 0x91, 0x42, 0x80, 0x28, 0xe4, 0x61, 0xe1, 0xf7, 0xa8, 0x05, 0xee, 0x5a,
  	0xd5, 0x81, 0xe3, 0x3e, 0xf5, 0x7a, 0x96, 0xd0, 0x0f, 0x41, 0xb1, 0x0f, 0x74, 0x94, 0x52, 0x1c,
  	0xc5, 0x3e, 0x50, 0x51, 0xde, 0x87, 0xb3, 0x84, 0x4b, 0xd7, 0xc7, 0x76, 0x88, 0x25, 0x56, 0x59,
  	0xc7, 0x3a, 0x33, 0x70, 0xdc, 0x25, 0x0a, 0xa2, 0x21, 0xda, 0x07, 0x09, 0xc4, 0x4a, 0x1c, 0xd1,
  	0x3e, 0xd0, 0x11, 0xcd, 0xf7, 0xa1, 0x18, 0xd9, 0x05, 0x4d, 0xc1, 0xf8, 0xda, 0xfa, 0x5a, 0xbb,
  	0x36, 0x86, 0x00, 0x26, 0x5b, 0x9b, 0x4b, 0xed, 0xb5, 0xe5, 0x9a, 0x81, 0x4a, 0x50, 0x58, 0x6e,
  	0xb3, 0x46, 0xae, 0x51, 0xf8, 0x82, 0xaf, 0xb7, 0x27, 0x00, 0xd2, 0x14, 0xa8, 0x00, 0xf9, 0x27,
  	0xed, 0x4f, 0x6b, 0x63, 0x04, 0xf8, 0x79, 0xdb, 0xda, 0x5c, 0x59, 0x5f, 0xab, 0x19, 0x84, 0xca,
  	0x92, 0xd5, 0x6e, 0x75, 0xda, 0xb5, 0x1c, 0x81, 0x78, 0xba, 0xbe, 0x5c, 0xcb, 0xa3, 0x22, 0x4c,
  	0x3c, 0x6f, 0xad, 0x3e, 0x6b, 0xd7, 0xc6, 0x23, 0x62, 0x72, 0x15, 0xff, 0x89, 0x01, 0x15, 0x6e,
  	0x6e, 0xb6, 0xb7, 0xd0, 0x3d, 0x98, 0xdc, 0xa5, 0xfb, 0x8b, 0xae, 0xe4, 0xd2, 0xc2, 0xe5, 0xd8,
  	0xda, 0xd0, 0xf6, 0xa0, 0xc5, 0x61, 0x91, 0x09, 0xf9, 0xbd, 0x51, 0x50, 0xcf, 0xcd, 0xe5, 0x6f,
  	0x96, 0x16, 0x6a, 0xf3, 0xcc, 0x93, 0xcc, 0x3f, 0xc1, 0x87, 0xcf, 0xed, 0xfe, 0x3e, 0xb6, 0xc8,
  	0x20, 0x42, 0x30, 0x3e, 0xf0, 0x7c, 0x4c, 0x17, 0xfc, 0x94, 0x45, 0xbf, 0xc9, 0x2e, 0xa0, 0x36,
  	0xe7, 0x8b, 0x9d, 0x35, 0xa4, 0x78, 0xff, 0x69, 0x00, 0x6c, 0xec, 0x87, 0xd9, 0x5b, 0x6c, 0x06,
  	0x26, 0x46, 0x84, 0x03, 0xdf, 0x5e, 0xac, 0x41, 0xf7, 0x16, 0xb6, 0x03, 0x1c, 0xed, 0x2d, 0xd2,
  	0x40, 0x73, 0x50, 0x18, 0xfa, 0x78, 0xb4, 0xb5, 0x37, 0xa2, 0xdc, 0xa6, 0xa4, 0x9d, 0x26, 0x49,
  	0xff, 0x93, 0x11, 0xba, 0x05, 0x65, 0x67, 0xc7, 0xf5, 0x7c, 0xbc, 0xc5, 0x88, 0x4e, 0xa8, 0x60,
  	0x0b, 0x56, 0x89, 0x0d, 0xd2, 0x29, 0x29, 0xb0, 0x8c, 0xd5, 0x64, 0x2a, 0xec, 0x2a, 0x19, 0x93,
  	0xf3, 0xf9, 0xdc, 0x80, 0x12, 0x9d, 0xcf, 0x89, 0x94, 0xbd, 0x20, 0x27, 0x92, 0xa3, 0x68, 0x09,
  	0x85, 0x27, 0xa6, 0x26, 0x45, 0x70, 0x01, 0x2d, 0xe3, 0x3e, 0x0e, 0xf1, 0x49, 0x9c, 0x97, 0xa2,
  	0xca, 0x7c, 0xaa, 0x2a, 0x25, 0xbf, 0xbf, 0x30, 0xe0, 0xac, 0xc6, 0xf0, 0x44, 0x53, 0xaf, 0x43,
  	0xa1, 0x47, 0x89, 0x31, 0x99, 0xf2, 0x96, 0x68, 0xa2, 0x7b, 0x30, 0xc5, 0x45, 0x0a, 0xea, 0xf9,
  	0xf4, 0x65, 0x28, 0xa5, 0x2c, 0x30, 0x29, 0x03, 0x29, 0xe6, 0x3f, 0xe5, 0xa0, 0xc8, 0x95, 0xb1,
  	0x3e, 0x44, 0x2d, 0xa8, 0xf8, 0xac, 0xb1, 0x45, 0xe7, 0xcc, 0x65, 0x6c, 0x64, 0xfb, 0xc9, 0xc7,
  	0x63, 0x56, 0x99, 0xa3, 0xd0, 0x6e, 0xf4, 0xab, 0x50, 0x12, 0x24, 0x86, 0xfb, 0x21, 0x37, 0x54,
  	0x5d, 0x27, 0x20, 0x97, 0xf6, 0xe3, 0x31, 0x0b, 0x38, 0xf8, 0xc6, 0x7e, 0x88, 0x3a, 0x30, 0x23,
  	0x90, 0xd9, 0xfc, 0xb8, 0x18, 0x79, 0x4a, 0x65, 0x4e, 0xa7, 0x92, 0x34, 0xe7, 0xe3, 0x31, 0x0b,
  	0x71, 0x7c, 0x65, 0x10, 0x2d, 0x4b, 0x91, 0xc2, 0x03, 0x16, 0x5f, 0x12, 0x22, 0x75, 0x0e, 0x5c,
  	0x4e, 0x44, 0x68, 0x6b, 0x51, 0x91, 0xad, 0x73, 0xe0, 0x46, 0x2a, 0x7b, 0x58, 0x84, 0x02, 0xef,
  	0x36, 0xff, 0x23, 0x07, 0x20, 0x2c, 0xb6, 0x3e, 0x44, 0xcb, 0x50, 0xf5, 0x79, 0x4b, 0xd3, 0xdf,
  	0xa5, 0x54, 0xfd, 0x71, 0x43, 0x8f, 0x59, 0x15, 0x81, 0xc4, 0xc4, 0xfd, 0x10, 0xca, 0x11, 0x15,
  	0xa9, 0xc2, 0x8b, 0x29, 0x2a, 0x8c, 0x28, 0x94, 0x04, 0x02, 0x51, 0xe2, 0x27, 0x70, 0x2e, 0xc2,
  	0x4f, 0xd1, 0xe2, 0x1b, 0x47, 0x68, 0x31, 0x22, 0x78, 0x56, 0x50, 0x50, 0xf5, 0xf8, 0x48, 0x11,
  	0x4c, 0x2a, 0xf2, 0x62, 0x8a, 0x22, 0x19, 0x90, 0xaa, 0xc9, 0x48, 0x42, 0x4d, 0x95, 0x40, 0xc2,
  	0x3e, 0xeb, 0x37, 0xff, 0x6a, 0x1c, 0x0a, 0x4b, 0xde, 0x60, 0x68, 0xfb, 0x64, 0x11, 0x4d, 0xfa,
  	0x38, 0xd8, 0xef, 0x87, 0x54, 0x81, 0xd5, 0x85, 0x6b, 0x3a, 0x0f, 0x0e, 0x26, 0xfe, 0x5a, 0x14,
  	0xd4, 0xe2, 0x28, 0x04, 0x99, 0x47, 0xf9, 0xdc, 0x6b, 0x20, 0xf3, 0x18, 0xcf, 0x51, 0x84, 0x43,
  	0xc8, 0x4b, 0x87, 0xd0, 0x80, 0x02, 0x3f, 0xe0, 0x31, 0x67, 0xfd, 0x78, 0xcc, 0x12, 0x1d, 0xe8,
  	0x6d, 0x98, 0x8e, 0x87, 0xc2, 0x09, 0x0e, 0x53, 0xed, 0xea, 0x91, 0xf3, 0x1a, 0x94, 0xb5, 0x08,
  	0x3d, 0xc9, 0xe1, 0x4a, 0x03, 0x25, 0x2e, 0x9f, 0x17, 0x6e, 0x9d, 0x1c, 0x2b, 0xca, 0x8f, 0xc7,
  	0x84, 0x63, 0xbf, 0x2a, 0x1c, 0xfb, 0x94, 0x1a, 0x68, 0x89, 0x5e, 0xb9, 0x8f, 0xbf, 0xae, 0x7a,
  	0xad, 0x6f, 0x12, 0xe4, 0x08, 0x48, 0xba, 0x2f, 0xd3, 0x82, 0x8a, 0xa6, 0x32, 0x12, 0x23, 0xdb,
  	0x1f, 0x3f, 0x6b, 0xad, 0xb2, 0x80, 0xfa, 0x88, 0xc6, 0x50, 0xab, 0x66, 0x90, 0x00, 0xbd, 0xda,
  	0xde, 0xdc, 0xac, 0xe5, 0xd0, 0x79, 0x28, 0xae, 0xad, 0x77, 0xb6, 0x18, 0x54, 0xbe, 0x51, 0xf8,
  	0x63, 0xe6, 0x49, 0x64, 0x7c, 0xfe, 0x34, 0xa2, 0xc9, 0x43, 0xb4, 0x12, 0x99, 0xc7, 0x94, 0xc8,
  	0x6c, 0x88, 0xc8, 0x9c, 0x93, 0x91, 0x39, 0x8f, 0x10, 0x4c, 0xac, 0xb6, 0x5b, 0x9b, 0x34, 0x48,
  	0x33, 0xd2, 0x8b, 0xc9, 0x68, 0xfd, 0xb0, 0x0a, 0x65, 0x66, 0x9e, 0xad, 0x7d, 0x97, 0x1c, 0x26,
  	0xfe, 0xda, 0x00, 0x90, 0x1b, 0x16, 0x35, 0xa1, 0xd0, 0x65, 0x22, 0xd4, 0x0d, 0xea, 0x01, 0xcf,
  	0xa5, 0x5a, 0xdc, 0x12, 0x50, 0xe8, 0x2e, 0x14, 0x82, 0xfd, 0x6e, 0x17, 0x07, 0x22, 0x72, 0x5f,
  	0x88, 0x3b, 0x61, 0xee, 0x10, 0x2d, 0x01, 0x47, 0x50, 0x5e, 0xda, 0x4e, 0x7f, 0x9f, 0xc6, 0xf1,
  	0xa3, 0x51, 0x38, 0x9c, 0xf4, 0xb1, 0x7f, 0x66, 0x40, 0x49, 0xd9, 0x16, 0xbf, 0x60, 0x08, 0xb8,
  	0x0c, 0x45, 0x2a, 0x0c, 0xee, 0xf1, 0x20, 0x30, 0x65, 0xc9, 0x0e, 0xf4, 0x1e, 0x14, 0xc5, 0x4e,
  	0x12, 0x71, 0xa0, 0x9e, 0x4e, 0x76, 0x7d, 0x68, 0x49, 0x50, 0x29, 0x64, 0x07, 0xce, 0x50, 0x3d,
  	0x75, 0xc9, 0xed, 0x43, 0x68, 0x56, 0x3d, 0x96, 0x1b, 0xb1, 0x63, 0x79, 0x03, 0xa6, 0x86, 0xbb,
  	0x87, 0x81, 0xd3, 0xb5, 0xfb, 0x5c, 0x9c, 0xa8, 0x2d, 0xa9, 0x6e, 0x02, 0x52, 0xa9, 0x9e, 0x44,
  	0x01, 0x92, 0xe8, 0x79, 0x28, 0x3d, 0xb6, 0x83, 0x5d, 0x2e, 0xa4, 0xec, 0xbf, 0x07, 0x15, 0xd2,
  	0xff, 0xe4, 0xf9, 0x6b, 0x88, 0x2f, 0xb0, 0x16, 0xcd, 0x7f, 0x36, 0xa0, 0x2a, 0xd0, 0x4e, 0x64,
  	0x20, 0x04, 0xe3, 0xbb, 0x76, 0xb0, 0x4b, 0x95, 0x51, 0xb1, 0xe8, 0x37, 0x7a, 0x1b, 0x6a, 0x5d,
  	0x36, 0xff, 0xad, 0xd8, 0xbd, 0x6b, 0x9a, 0xf7, 0x47, 0x7b, 0xff, 0x5d, 0xa8, 0x10, 0x94, 0x2d,
  	0xfd, 0x1e, 0x24, 0xb6, 0xf1, 0x7b, 0x56, 0x79, 0x97, 0xce, 0x39, 0x2e, 0xbe, 0x0d, 0x65, 0xa6,
  	0x8c, 0xd3, 0x96, 0x5d, 0xea, 0xb5, 0x01, 0xd3, 0x9b, 0xae, 0x3d, 0x0c, 0x76, 0xbd, 0x30, 0xa6,
  	0xf3, 0x45, 0xf3, 0xef, 0x0d, 0xa8, 0xc9, 0xc1, 0x13, 0xc9, 0xf0, 0x16, 0x4c, 0xfb, 0x78, 0x60,
  	0x3b, 0xae, 0xe3, 0xee, 0x6c, 0x6d, 0x1f, 0x86, 0x38, 0xe0, 0xd7, 0xd7, 0x6a, 0xd4, 0xfd, 0x90,
  	0xf4, 0x12, 0x61, 0xb7, 0xfb, 0xde, 0x36, 0x77, 0xd2, 0xf4, 0x1b, 0xbd, 0xa1, 0x7b, 0xe9, 0xa2,
  	0xd4, 0x9b, 0xe8, 0x97, 0x32, 0xff, 0x34, 0x07, 0xe5, 0x4f, 0xec, 0xb0, 0x2b, 0x56, 0x10, 0x5a,
  	0x81, 0x6a, 0xe4, 0xc6, 0x69, 0x0f, 0x97, 0x3b, 0x76, 0xe0, 0xa0, 0x38, 0xe2, 0x5e, 0x23, 0x0e,
  	0x1c, 0x95, 0xae, 0xda, 0x41, 0x49, 0xd9, 0x6e, 0x17, 0xf7, 0x23, 0x52, 0xb9, 0x6c, 0x52, 0x14,
  	0x50, 0x25, 0xa5, 0x76, 0xa0, 0x6f, 0x43, 0x6d, 0xe8, 0x7b, 0x3b, 0x3e, 0x0e, 0x82, 0x88, 0x18,
  	0x0b, 0xe1, 0x66, 0x0a, 0xb1, 0x0d, 0x0e, 0x1a, 0x3b, 0xc5, 0xdc, 0x7b, 0x3c, 0x66, 0x4d, 0x0f,
  	0xf5, 0x31, 0xe9, 0x58, 0xa7, 0xe5, 0x79, 0x8f, 0x79, 0xd6, 0x1f, 0xe5, 0x01, 0x25, 0xa7, 0xf9,
  	0x55, 0x8f, 0xc9, 0x37, 0xa0, 0x1a, 0x84, 0xb6, 0x9f, 0x58, 0xf3, 0x15, 0xda, 0x1b, 0xad, 0xf8,
  	0xb7, 0x20, 0x92, 0x6c, 0xcb, 0xf5, 0x42, 0xe7, 0xe5, 0x21, 0xbb, 0xa0, 0x58, 0x55, 0xd1, 0xbd,
  	0x46, 0x7b, 0xd1, 0x1a, 0x14, 0x5e, 0x3a, 0xfd, 0x10, 0xfb, 0x41, 0x7d, 0x62, 0x2e, 0x7f, 0xb3,
  	0xba, 0xf0, 0xce, 0x71, 0x86, 0x99, 0xff, 0x88, 0xc2, 0x77, 0x0e, 0x87, 0xea, 0xe9, 0x97, 0x13,
  	0x51, 0x8f, 0xf1, 0x93, 0xe9, 0x37, 0x22, 0x13, 0xa6, 0x5e, 0x11, 0xa2, 0x5b, 0x4e, 0x8f, 0xc6,
  	0xe2, 0x68, 0x1f, 0xde, 0xb3, 0x0a, 0x74, 0x60, 0xa5, 0x87, 0xae, 0xc1, 0xd4, 0x4b, 0xdf, 0xde,
  	0x19, 0x60, 0x37, 0x64, 0xb7, 0x7c, 0x09, 0x13, 0x0d, 0x98, 0xf3, 0x00, 0x52, 0x14, 0x12, 0xf9,
  	0xd6, 0xd6, 0x37, 0x9e, 0x75, 0x6a, 0x63, 0xa8, 0x0c, 0x53, 0x6b, 0xeb, 0xcb, 0xed, 0xd5, 0x36,
  	0x89, 0x8d, 0x22, 0xe6, 0xdd, 0x95, 0x9b, 0xae, 0x25, 0x0c, 0xa1, 0xad, 0x09, 0x55, 0x2e, 0x43,
  	0xbf, 0x74, 0x0b, 0xb9, 0x04, 0x89, 0xbb, 0xe6, 0x55, 0x98, 0x49, 0x5b, 0x1a, 0x02, 0xe0, 0x9e,
  	0xf9, 0x6f, 0x39, 0xa8, 0xf0, 0x8d, 0x70, 0xa2, 0x9d, 0x7b, 0x51, 0x91, 0x8a, 0x5f, 0x4f, 0x84,
  	0x92, 0xea, 0x50, 0x60, 0x1b, 0xa4, 0xc7, 0xef, 0xbf, 0xa2, 0x49, 0x9c, 0x33, 0x5b, 0xef, 0xb8,
  	0xc7, 0xcd, 0x1e, 0xb5, 0x53, 0xdd, 0xe6, 0x44, 0xa6, 0xdb, 0x8c, 0x36, 0x9c, 0x1d, 0xf0, 0x83,
  	0x55, 0x51, 0x9a, 0xa2, 0x2c, 0x36, 0x15, 0x19, 0xd4, 0x6c, 0x56, 0xc8, 0xb0, 0x19, 0xba, 0x01,
  	0x93, 0x78, 0x84, 0xdd, 0x30, 0xa8, 0x97, 0x68, 0x20, 0xad, 0x88, 0x0b, 0x55, 0x9b, 0xf4, 0x5a,
  	0x7c, 0x50, 0x9a, 0xea, 0x43, 0x38, 0x43, 0xef, 0xbb, 0x8f, 0x7c, 0xdb, 0x55, 0xef, 0xec, 0x9d,
  	0xce, 0x2a, 0x0f, 0x3b, 0xe4, 0x13, 0x55, 0x21, 0xb7, 0xb2, 0xcc, 0xf5, 0x93, 0x5b, 0x59, 0x96,
  	0xf8, 0xbf, 0x6f, 0x00, 0x52, 0x09, 0x9c, 0xc8, 0x16, 0x31, 0x2e, 0x42, 0x8e, 0xbc, 0x94, 0x63,
  	0x06, 0x26, 0xb0, 0xef, 0x7b, 0x3e, 0x73, 0x94, 0x16, 0x6b, 0x48, 0x69, 0x6e, 0x73, 0x61, 0x2c,
  	0x3c, 0xf2, 0xf6, 0x22, 0x0f, 0xc0, 0xc8, 0x1a, 0x49, 0xe1, 0x3b, 0x70, 0x56, 0x03, 0x3f, 0x9d,
  	0x10, 0xbf, 0x0e, 0xd3, 0x94, 0xea, 0xd2, 0x2e, 0xee, 0xee, 0x0d, 0x3d, 0xc7, 0x4d, 0x48, 0x80,
  	0xae, 0x11, 0xdf, 0x25, 0xc2, 0x05, 0x99, 0x22, 0x9b, 0x73, 0x39, 0xea, 0xec, 0x74, 0x56, 0xe5,
  	0x52, 0xdf, 0x86, 0xf3, 0x31, 0x82, 0x62, 0x66, 0xbf, 0x06, 0xa5, 0x6e, 0xd4, 0x19, 0xf0, 0x13,
  	0xe4, 0x15, 0x5d, 0xdc, 0x38, 0xaa, 0x8a, 0x21, 0x79, 0x7c, 0x1b, 0x2e, 0x24, 0x78, 0x9c, 0x86,
  	0x3a, 0xee, 0x99, 0x77, 0xe0, 0x1c, 0xa5, 0xfc, 0x04, 0xe3, 0x61, 0xab, 0xef, 0x8c, 0x8e, 0x37,
  	0xcb, 0x21, 0x9f, 0xaf, 0x82, 0xf1, 0xf5, 0x2e, 0x2b, 0xc9, 0xba, 0xcd, 0x59, 0x77, 0x9c, 0x01,
  	0xee, 0x78, 0xab, 0xd9, 0xd2, 0x92, 0x40, 0xbe, 0x87, 0x0f, 0x03, 0x7e, 0x7c, 0xa4, 0xdf, 0xd2,
  	0x7b, 0xfd, 0xad, 0xc1, 0xd5, 0xa9, 0xd2, 0xf9, 0x9a, 0xb7, 0xc6, 0x2c, 0xc0, 0x0e, 0xd9, 0x83,
  	0xb8, 0x47, 0x06, 0x58, 0x6e, 0x4e, 0xe9, 0x89, 0x04, 0x26, 0x51, 0xa8, 0x1c, 0x17, 0xf8, 0x0a,
  	0xdf, 0x38, 0xf4, 0x9f, 0x20, 0x71, 0x52, 0x7a, 0x13, 0x4a, 0x74, 0x64, 0x33, 0xb4, 0xc3, 0xfd,
  	0x20, 0xcb, 0x72, 0x8b, 0xe6, 0x8f, 0x0c, 0xbe, 0xa3, 0x04, 0x9d, 0x13, 0xcd, 0xf9, 0x2e, 0x4c,
  	0xd2, 0x1b, 0xa2, 0xb8, 0xe9, 0x5c, 0x4c, 0x59, 0xd8, 0x4c, 0x22, 0x8b, 0x03, 0x2a, 0xe7, 0x24,
  	0x03, 0x26, 0x9f, 0xd2, 0xca, 0x81, 0x22, 0xed, 0xb8, 0xb0, 0x9c, 0x6b, 0x0f, 0x58, 0xfa, 0xb1,
  	0x68, 0xd1, 0x6f, 0x7a, 0x21, 0xc0, 0xd8, 0x7f, 0x66, 0xad, 0xb2, 0x1b, 0x48, 0xd1, 0x8a, 0xda,
  	0x44, 0xb1, 0xdd, 0xbe, 0x83, 0xdd, 0x90, 0x8e, 0x8e, 0xd3, 0x51, 0xa5, 0x07, 0xdd, 0x80, 0xa2,
  	0x13, 0xac, 0x62, 0xdb, 0x77, 0x79, 0x8a, 0x5f, 0x71, 0xcc, 0x72, 0x44, 0xae, 0xb1, 0xef, 0x40,
  	0x8d, 0x49, 0xd6, 0xea, 0xf5, 0x94, 0xd3, 0x7e, 0xc4, 0xdf, 0x88, 0xf1, 0xd7, 0xe8, 0xe7, 0x8e,
  	0xa7, 0xff, 0x77, 0x06, 0x9c, 0x51, 0x18, 0x9c, 0xc8, 0x04, 0xef, 0xc2, 0x24, 0xab, 0xbf, 0xf0,
  	0xa3, 0xe0, 0x8c, 0x8e, 0xc5, 0xd8, 0x58, 0x1c, 0x06, 0xcd, 0x43, 0x81, 0x7d, 0x89, 0x6b, 0x5c,
  	0x3a, 0xb8, 0x00, 0x92, 0x22, 0xcf, 0xc3, 0x59, 0x3e, 0x86, 0x07, 0x5e, 0xda, 0x9e, 0x1b, 0xd7,
  	0x3d, 0xc4, 0x0f, 0x0d, 0x98, 0xd1, 0x11, 0x4e, 0x34, 0x4b, 0x45, 0xee, 0xdc, 0x57, 0x92, 0xfb,
  	0x5b, 0x42, 0xee, 0x67, 0xc3, 0x9e, 0x72, 0xe4, 0x8c, 0xaf, 0x38, 0xd5, 0xba, 0x39, 0xdd, 0xba,
  	0x92, 0xd6, 0x4f, 0xa2, 0x39, 0x09, 0x62, 0x27, 0x9a, 0xd3, 0xfb, 0xaf, 0x35, 0x27, 0xe5, 0x08,
  	0x96, 0x98, 0xdc, 0x8a, 0x58, 0x46, 0xab, 0x4e, 0x10, 0x45, 0x9c, 0x77, 0xa0, 0xdc, 0x77, 0x5c,
  	0x6c, 0xfb, 0xbc, 0x86, 0x64, 0xa8, 0xeb, 0xf1, 0xbe, 0xa5, 0x0d, 0x4a, 0x52, 0xbf, 0x6d, 0x00,
  	0x52, 0x69, 0xfd, 0x72, 0xac, 0xd5, 0x14, 0x0a, 0xde, 0xf0, 0xbd, 0x81, 0x17, 0x1e, 0xb7, 0xcc,
  	0xee, 0x99, 0xbf, 0x6b, 0xc0, 0xb9, 0x18, 0xc6, 0x2f, 0x43, 0xf2, 0x7b, 0xe6, 0x65, 0x38, 0xb3,
  	0x8c, 0xc5, 0x19, 0x2f, 0x91, 0x3b, 0xd8, 0x04, 0xa4, 0x8e, 0x9e, 0xce, 0x29, 0xe6, 0x1b, 0x70,
  	0xe6, 0xa9, 0x37, 0x22, 0x8e, 0x9c, 0x0c, 0x4b, 0x37, 0xc5, 0x92, 0x59, 0x91, 0xbe, 0xa2, 0xb6,
  	0x74, 0xbd, 0x9b, 0x80, 0x54, 0xcc, 0xd3, 0x10, 0x67, 0xd1, 0xfc, 0x5f, 0x03, 0xca, 0xad, 0xbe,
  	0xed, 0x0f, 0x84, 0x28, 0x1f, 0xc2, 0x24, 0xcb, 0xcc, 0xf0, 0x34, 0xeb, 0x9b, 0x3a, 0x3d, 0x15,
  	0x96, 0x35, 0x5a, 0x2c, 0x8f, 0xc3, 0xb1, 0xc8, 0x54, 0x78, 0x65, 0x79, 0x39, 0x56, 0x69, 0x5e,
  	0x46, 0xb7, 0x61, 0xc2, 0x26, 0x28, 0x34, 0xbc, 0x56, 0xe3, 0xe9, 0x32, 0x4a, 0x8d, 0x5c, 0x89,
  	0x2c, 0x06, 0x65, 0x7e, 0x00, 0x25, 0x85, 0x03, 0x2a, 0x40, 0xfe, 0x51, 0x9b, 0x5f, 0x93, 0x5a,
  	0x4b, 0x9d, 0x95, 0xe7, 0x2c, 0x85, 0x58, 0x05, 0x58, 0x6e, 0x47, 0xed, 0x5c, 0x4a, 0x61, 0xcf,
  	0xe6, 0x74, 0x78, 0xdc, 0x52, 0x25, 0x34, 0xb2, 0x24, 0xcc, 0xbd, 0x8e, 0x84, 0x92, 0xc5, 0x6f,
  	0x19, 0x50, 0xe1, 0xaa, 0x39, 0x69, 0x68, 0xa6, 0x94, 0x33, 0x42, 0xb3, 0x32, 0x0d, 0x8b, 0x03,
  	0x4a, 0x19, 0xfe, 0xc5, 0x80, 0xda, 0xb2, 0xf7, 0xca, 0xdd, 0xf1, 0xed, 0x5e, 0xb4, 0x07, 0x3f,
  	0x8a, 0x99, 0x73, 0x3e, 0x96, 0xe9, 0x8f, 0xc1, 0xcb, 0x8e, 0x98, 0x59, 0xeb, 0x32, 0x97, 0xc2,
  	0xe2, 0xbb, 0x68, 0x9a, 0xdf, 0x84, 0xe9, 0x18, 0x12, 0x31, 0xd0, 0xf3, 0xd6, 0xea, 0xca, 0x32,
  	0x31, 0x08, 0xcd, 0xf7, 0xb6, 0xd7, 0x5a, 0x0f, 0x57, 0xdb, 0xbc, 0x2a, 0xdb, 0x5a, 0x5b, 0x6a,
  	0xaf, 0x4a, 0x43, 0xdd, 0x17, 0x33, 0xb8, 0x6f, 0xf6, 0xe1, 0x8c, 0x22, 0xd0, 0x49, 0x8b, 0x63,
  	0xe9, 0xf2, 0x4a, 0x6e, 0xdf, 0x80, 0x4b, 0x11, 0xb7, 0xe7, 0x6c, 0xb0, 0x83, 0x03, 0xf5, 0xb2,
  	0x36, 0xe2, 0x4c, 0x8b, 0x16, 0xf9, 0x14, 0x98, 0xef, 0x99, 0x75, 0xa8, 0xf0, 0xf3, 0x51, 0xdc,
  	0x65, 0xfc, 0xf9, 0x38, 0x54, 0xc5, 0xd0, 0xd7, 0x23, 0x3f, 0x3a, 0x0f, 0x93, 0xbd, 0xed, 0x4d,
  	0xe7, 0x33, 0x51, 0xd1, 0xe5, 0x2d, 0xd2, 0xdf, 0x67, 0x7c, 0xd8, 0x3b, 0x0d, 0xde, 0x42, 0x97,
  	0xd9, 0x13, 0x8e, 0x15, 0xb7, 0x87, 0x0f, 0xe8, 0x31, 0x6a, 0xdc, 0x92, 0x1d, 0x34, 0x1d, 0xca,
  	0xdf, 0x73, 0xd0, 0x5b, 0xb2, 0xf2, 0xbe, 0x03, 0x2d, 0x42, 0x8d, 0x7c, 0xb7, 0x86, 0xc3, 0xbe,
  	0x83, 0x7b, 0x8c, 0x00, 0xb9, 0x20, 0x8f, 0xcb, 0x73, 0x52, 0x02, 0x00, 0x5d, 0x85, 0x49, 0x7a,
  	0x79, 0x0c, 0xea, 0x53, 0x24, 0x22, 0x4b, 0x50, 0xde, 0x8d, 0xde, 0x86, 0x12, 0x93, 0x78, 0xc5,
  	0x7d, 0x16, 0x60, 0xfa, 0xda, 0x41, 0xc9, 0xa4, 0xa8, 0x63, 0xfa, 0x09, 0x0d, 0xb2, 0x4e, 0x68,
  	0xa8, 0x09, 0xd5, 0x20, 0xf4, 0x7c, 0x7b, 0x47, 0x98, 0x91, 0x3e, 0x75, 0x50, 0xd2, 0x7d, 0xb1,
  	0x61, 0x29, 0xc2, 0xc7, 0xfb, 0x5e, 0x68, 0xeb, 0x4f, 0x1c, 0xde, 0xb3, 0xd4, 0x31, 0xf4, 0x2d,
  	0xa8, 0xf4, 0xc4, 0x22, 0x59, 0x71, 0x5f, 0x7a, 0xf4, 0x59, 0x43, 0xa2, 0x7a, 0xb7, 0xac, 0x82,
  	0x48, 0x4a, 0x3a, 0xaa, 0x7a, 0x93, 0xad, 0x68, 0x18, 0xc4, 0xda, 0xd8, 0x25, 0xa1, 0x9d, 0x65,
  	0x70, 0xa6, 0x2c, 0xd1, 0x44, 0xd7, 0xa1, 0xc2, 0x22, 0xc1, 0x73, 0x6d, 0x35, 0xe8, 0x9d, 0x24,
  	0x8e, 0xb5, 0xf6, 0xc3, 0xdd, 0x36, 0x45, 0x4a, 0x2c, 0xca, 0x2b, 0x80, 0xc8, 0xe8, 0xb2, 0x13,
  	0xa4, 0x0e, 0x73, 0xe4, 0xd4, 0x15, 0x7d, 0xdf, 0x5c, 0x83, 0xb3, 0x64, 0x14, 0xbb, 0xa1, 0xd3,
  	0x55, 0x8e, 0x62, 0xe2, 0xb0, 0x6f, 0xc4, 0x0e, 0xfb, 0x76, 0x10, 0xbc, 0xf2, 0xfc, 0x1e, 0x17,
  	0x33, 0x6a, 0x4b, 0x6e, 0xff, 0x68, 0x30, 0x69, 0x9e, 0x05, 0xda, 0x41, 0xfd, 0x2b, 0xd2, 0x43,
  	0xbf, 0x02, 0x05, 0xfe, 0x40, 0x8a, 0xe7, 0x3f, 0xcf, 0xcf, 0xb3, 0x87, 0x59, 0xf3, 0x9c, 0xf0,
  	0x3a, 0x1b, 0x55, 0x72, 0x74, 0x1c, 0x9e, 0x2c, 0x97, 0x5d, 0x3b, 0xd8, 0xc5, 0xbd, 0x0d, 0x41,
  	0x5c, 0xcb, 0x0e, 0xdf, 0xb7, 0x62, 0xc3, 0x52, 0xf6, 0xbb, 0x52, 0xf4, 0x47, 0x38, 0x3c, 0x42,
  	0x74, 0xb5, 0xfe, 0x70, 0x4e, 0xa0, 0xf0, 0xb2, 0xe9, 0xeb, 0x60, 0xfd, 0xd8, 0x80, 0x2b, 0x02,
  	0x6d, 0x69, 0xd7, 0x76, 0x77, 0xb0, 0x10, 0xe6, 0x17, 0xd5, 0x57, 0x72, 0xd2, 0xf9, 0xd7, 0x9c,
  	0xf4, 0x13, 0xa8, 0x47, 0x93, 0xa6, 0xb9, 0x28, 0xaf, 0xaf, 0x4e, 0x62, 0x3f, 0x88, 0x9c, 0x24,
  	0xfd, 0x26, 0x7d, 0xbe, 0xd7, 0x8f, 0xae, 0x81, 0xe4, 0x5b, 0x12, 0x5b, 0x85, 0x8b, 0x82, 0x18,
  	0x4f, 0x0e, 0xe9, 0xd4, 0x12, 0x73, 0x3a, 0x92, 0x1a, 0xb7, 0x07, 0xa1, 0x71, 0xf4, 0x52, 0x4a,
  	0x45, 0xd1, 0x4d, 0x48, 0xb9, 0x18, 0x69, 0x5c, 0x66, 0xd9, 0x0e, 0x20, 0x32, 0x2b, 0x27, 0xf6,
  	0xc4, 0x38, 0x21, 0x99, 0x3a, 0xce, 0x97, 0x00, 0x19, 0x4f, 0x2c, 0x81, 0x6c, 0xae, 0x18, 0x66,
  	0x23, 0x41, 0x89, 0xda, 0x37, 0xb0, 0x3f, 0x70, 0x82, 0x40, 0x29, 0xc4, 0xa5, 0xa9, 0xeb, 0x4d,
  	0x18, 0x1f, 0x62, 0x7e, 0x7c, 0x29, 0x2d, 0x20, 0xb1, 0x27, 0x14, 0x64, 0x3a, 0x2e, 0xd9, 0x0c,
  	0xe0, 0xaa, 0x60, 0xc3, 0x0c, 0x92, 0xca, 0x27, 0x2e, 0xa6, 0x48, 0xfe, 0xe7, 0x32, 0x92, 0xff,
  	0x79, 0x3d, 0xf9, 0xaf, 0x1d, 0xa9, 0x55, 0x47, 0x75, 0x3a, 0x47, 0xea, 0x0e, 0x33, 0x40, 0xe4,
  	0xdf, 0x4e, 0x87, 0xea, 0x1f, 0x70, 0x47, 0x75, 0x5a, 0xe1, 0x5c, 0x38, 0xf8, 0x9c, 0xee, 0xe0,
  	0x4d, 0x28, 0x13, 0x23, 0x59, 0x6a, 0x55, 0x64, 0xdc, 0xd2, 0xfa, 0xa4, 0x33, 0xde, 0x83, 0x19,
  	0xdd, 0x19, 0x9f, 0x48, 0xa8, 0x19, 0x98, 0x08, 0xbd, 0x3d, 0x2c, 0x62, 0x0a, 0x6b, 0x24, 0xd4,
  	0x1a, 0x39, 0xea, 0xd3, 0x51, 0xeb, 0x77, 0x25, 0x55, 0xba, 0x01, 0x4f, 0x3a, 0x03, 0xb2, 0x1c,
  	0xc5, 0xed, 0x9f, 0x35, 0x24, 0xaf, 0x4f, 0xe0, 0x7c, 0xdc, 0xf9, 0x9e, 0xce, 0x24, 0xb6, 0xd8,
  	0xe6, 0x4c, 0x73, 0xcf, 0xa7, 0xc3, 0xe0, 0x85, 0xf4, 0x93, 0x8a, 0xd3, 0x3d, 0x1d, 0xda, 0xbf,
  	0x0e, 0x8d, 0x34, 0x1f, 0x7c, 0xaa, 0x7b, 0x31, 0x72, 0xc9, 0xa7, 0x43, 0xf5, 0x87, 0x86, 0x24,
  	0xab, 0xae, 0x9a, 0x0f, 0xbe, 0x0a, 0x59, 0x11, 0xeb, 0xee, 0x44, 0xcb, 0xa7, 0x19, 0x79, 0xcb,
  	0x7c, 0xba, 0xb7, 0x94, 0x28, 0x14, 0x50, 0xec, 0x3f, 0xe9, 0xea, 0xbf, 0xce, 0xd5, 0xcb, 0x99,
  	0xc9, 0xb8, 0x73, 0x52, 0x66, 0x24, 0x3c, 0x47, 0xcc, 0x68, 0x23, 0xb1, 0x55, 0xd4, 0x20, 0x75,
  	0x3a, 0xa6, 0xfb, 0x0d, 0x19, 0x60, 0x12, 0x71, 0xec, 0x74, 0x38, 0xd8, 0x30, 0x97, 0x1d, 0xc2,
  	0x4e, 0x85, 0xc5, 0xad, 0x16, 0x14, 0xa3, 0xbb, 0xbf, 0xf2, 0x52, 0xb9, 0x04, 0x85, 0xb5, 0xf5,
  	0xcd, 0x8d, 0xd6, 0x12, 0xb9, 0xda, 0xce, 0x40, 0x61, 0x69, 0xdd, 0xb2, 0x9e, 0x6d, 0x74, 0xc8,
  	0xdd, 0x36, 0xfe, 0x70, 0x69, 0xe1, 0x67, 0x79, 0xc8, 0x3d, 0x79, 0x8e, 0x3e, 0x85, 0x09, 0xf6,
  	0x70, 0xee, 0x88, 0xf7, 0x93, 0x8d, 0xa3, 0xde, 0x06, 0x9a, 0x17, 0x7e, 0xf0, 0xdf, 0x3f, 0xfb,
  	0xc3, 0xdc, 0x19, 0xb3, 0xdc, 0x1c, 0x2d, 0x36, 0xf7, 0x46, 0x4d, 0x1a, 0x64, 0x1f, 0x18, 0xb7,
  	0xd0, 0xc7, 0x90, 0xdf, 0xd8, 0x0f, 0x51, 0xe6, 0xbb, 0xca, 0x46, 0xf6, 0x73, 0x41, 0xf3, 0x1c,
  	0x25, 0x3a, 0x6d, 0x02, 0x27, 0x3a, 0xdc, 0x0f, 0x09, 0xc9, 0xef, 0x41, 0x49, 0x7d, 0xec, 0x77,
  	0xec, 0x63, 0xcb, 0xc6, 0xf1, 0x0f, 0x09, 0xcd, 0x2b, 0x94, 0xd5, 0x05, 0x13, 0x71, 0x56, 0xec,
  	0x39, 0xa2, 0x3a, 0x8b, 0xce, 0x81, 0x8b, 0x32, 0x9f, 0x62, 0x36, 0xb2, 0xdf, 0x16, 0x26, 0x66,
  	0x11, 0x1e, 0xb8, 0x84, 0xe4, 0x77, 0xf9, 0x23, 0xc2, 0x6e, 0x88, 0xae, 0xa6, 0xbc, 0x02, 0x53,
  	0x5f, 0x37, 0x35, 0xe6, 0xb2, 0x01, 0x38, 0x93, 0xcb, 0x94, 0xc9, 0x79, 0xf3, 0x0c, 0x67, 0xd2,
  	0x8d, 0x40, 0x1e, 0x18, 0xb7, 0x16, 0xba, 0x30, 0x41, 0xab, 0xe7, 0xe8, 0x85, 0xf8, 0x68, 0xa4,
  	0xbc, 0x4b, 0xc8, 0x30, 0xb4, 0x56, 0x77, 0x37, 0x67, 0x28, 0xa3, 0xaa, 0x59, 0x24, 0x8c, 0x68,
  	0xed, 0xfc, 0x81, 0x71, 0xeb, 0xa6, 0x71, 0xc7, 0x58, 0xf8, 0x9b, 0x09, 0x98, 0xa0, 0x55, 0x1a,
  	0xb4, 0x07, 0x20, 0xab, 0xc4, 0xf1, 0xd9, 0x25, 0x0a, 0xd0, 0xf1, 0xd9, 0x25, 0x0b, 0xcc, 0x66,
  	0x83, 0x32, 0x9d, 0x31, 0xa7, 0x09, 0x53, 0x5a, 0xfc, 0x69, 0xd2, 0x5a, 0x17, 0xd1, 0xe3, 0x8f,
  	0x0d, 0x5e, 0xae, 0x62, 0xdb, 0x0c, 0xa5, 0x51, 0xd3, 0x2a, 0xc4, 0xf1, 0xe5, 0x90, 0x52, 0x14,
  	0x36, 0xef, 0x53, 0x86, 0x4d, 0xb3, 0x26, 0x19, 0xfa, 0x14, 0xe2, 0x81, 0x71, 0xeb, 0x45, 0xdd,
  	0x3c, 0xcb, 0xb5, 0x1c, 0x1b, 0x41, 0xdf, 0x87, 0xaa, 0x5e, 0xcb, 0x44, 0xd7, 0x52, 0x78, 0xc5,
  	0x6b, 0xa3, 0x8d, 0xeb, 0x47, 0x03, 0x71, 0x99, 0x66, 0xa9, 0x4c, 0x9c, 0x39, 0xe3, 0xbc, 0x87,
  	0xf1, 0xd0, 0x26, 0x40, 0xdc, 0x06, 0xe8, 0x4f, 0x0d, 0x5e, 0x8e, 0x96, 0xa5, 0x48, 0x94, 0x46,
  	0x3d, 0x51, 0xf1, 0x6c, 0xdc, 0x38, 0x06, 0x8a, 0x0b, 0xf1, 0x01, 0x15, 0xe2, 0x7d, 0x73, 0x46,
  	0x0a, 0x11, 0x3a, 0x03, 0x1c, 0x7a, 0x5c, 0x8a, 0x17, 0x97, 0xcd, 0x0b, 0x9a, 0x72, 0xb4, 0x51,
  	0x69, 0x2c, 0x56, 0x32, 0x4c, 0x35, 0x96, 0x56, 0x95, 0x4c, 0x35, 0x96, 0x5e, 0x6f, 0x4c, 0x33,
  	0x16, 0x2f, 0x10, 0xa6, 0x18, 0x2b, 0x1a, 0x59, 0xf8, 0xff, 0x71, 0x28, 0x2c, 0xb1, 0xff, 0x8c,
  	0x84, 0x3c, 0x28, 0x46, 0x45, 0x34, 0x34, 0x9b, 0x96, 0xa7, 0x97, 0x57, 0xb9, 0xc6, 0xd5, 0xcc,
  	0x71, 0x2e, 0xd0, 0x1b, 0x54, 0xa0, 0x4b, 0xe6, 0x79, 0xc2, 0x99, 0xff, 0x7f, 0xa7, 0x26, 0xcb,
  	0xe6, 0x36, 0xed, 0x5e, 0x8f, 0x28, 0xe2, 0x37, 0xa1, 0xac, 0x96, 0xb4, 0xd0, 0x1b, 0xa9, 0xb5,
  	0x01, 0xb5, 0x3e, 0xd6, 0x30, 0x8f, 0x02, 0xe1, 0x9c, 0xaf, 0x53, 0xce, 0xb3, 0xe6, 0xc5, 0x14,
  	0xce, 0x3e, 0x05, 0xd5, 0x98, 0xb3, 0xda, 0x53, 0x3a, 0x73, 0xad, 0xc8, 0x95, 0xce, 0x5c, 0x2f,
  	0x5d, 0x1d, 0xc9, 0x7c, 0x9f, 0x82, 0x12, 0xe6, 0x01, 0x80, 0x2c, 0x0e, 0xa1, 0x54, 0x5d, 0x2a,
  	0x17, 0xd6, 0xb8, 0x73, 0x48, 0xd6, 0x95, 0x4c, 0x93, 0xb2, 0xe5, 0xeb, 0x2e, 0xc6, 0xb6, 0xef,
  	0x04, 0x21, 0xdb, 0x98, 0x15, 0xad, 0xb4, 0x83, 0x52, 0xe7, 0xa3, 0x57, 0x8a, 0x1a, 0xd7, 0x8e,
  	0x84, 0xe1, 0xdc, 0x6f, 0x50, 0xee, 0x57, 0xcd, 0x46, 0x0a, 0xf7, 0x21, 0x83, 0x25, 0x8b, 0xed,
  	0xf3, 0x02, 0x94, 0x9e, 0xda, 0x8e, 0x1b, 0x62, 0xd7, 0x76, 0xbb, 0x18, 0x6d, 0xc3, 0x04, 0x8d,
  	0xdd, 0x71, 0x47, 0xac, 0x56, 0x32, 0xe2, 0x8e, 0x58, 0x4b, 0xe5, 0x9b, 0x73, 0x94, 0x71, 0xc3,
  	0x3c, 0x47, 0x18, 0x0f, 0x24, 0xe9, 0x26, 0x2b, 0x02, 0x18, 0xb7, 0xd0, 0x4b, 0x98, 0xe4, 0x25,
  	0xfc, 0x18, 0x21, 0x2d, 0xa9, 0xd6, 0xb8, 0x9c, 0x3e, 0x98, 0xb6, 0x96, 0x55, 0x36, 0x01, 0x85,
  	0x23, 0x7c, 0x46, 0x00, 0xb2, 0x22, 0x15, 0xb7, 0x68, 0xa2, 0x92, 0xd5, 0x98, 0xcb, 0x06, 0x48,
  	0xd3, 0xa9, 0xca, 0xb3, 0x17, 0xc1, 0x12, 0xbe, 0xdf, 0x81, 0xf1, 0xc7, 0x76, 0xb0, 0x8b, 0x62,
  	0xb1, 0x57, 0x79, 0x71, 0xdb, 0x68, 0xa4, 0x0d, 0x71, 0x2e, 0x57, 0x29, 0x97, 0x8b, 0xcc, 0x95,
  	0xa9, 0x5c, 0xe8, 0x9b, 0x52, 0xa6, 0x3f, 0xf6, 0xdc, 0x36, 0xae, 0x3f, 0xed, 0xed, 0x6e, 0x5c,
  	0x7f, 0xfa, 0x0b, 0xdd, 0x6c, 0xfd, 0x11, 0x2e, 0x7b, 0x23, 0xc2, 0x67, 0x08, 0x53, 0xe2, 0x61,
  	0x2a, 0x8a, 0x3d, 0xe7, 0x89, 0xbd, 0x66, 0x6d, 0xcc, 0x66, 0x0d, 0x73, 0x6e, 0xd7, 0x28, 0xb7,
  	0x2b, 0x66, 0x3d, 0x61, 0x2d, 0x0e, 0xf9, 0xc0, 0xb8, 0x75, 0xc7, 0x40, 0xdf, 0x07, 0x90, 0x45,
  	0xbb, 0xc4, 0x1e, 0x8c, 0x17, 0x02, 0x13, 0x7b, 0x30, 0x51, 0xef, 0x33, 0xe7, 0x29, 0xdf, 0x9b,
  	0xe6, 0xb5, 0x38, 0xdf, 0xd0, 0xb7, 0xdd, 0xe0, 0x25, 0xf6, 0x6f, 0xb3, 0xbc, 0x7f, 0xb0, 0xeb,
  	0x0c, 0xc9, 0x94, 0x7d, 0x28, 0x46, 0xb9, 0xe6, 0xb8, 0xbf, 0x8d, 0x57, 0x7f, 0xe2, 0xfe, 0x36,
  	0x51, 0x8c, 0xd1, 0x1d, 0x8f, 0xb6, 0x5e, 0x04, 0x28, 0xd9, 0x82, 0x7f, 0x59, 0x83, 0x71, 0x72,
  	0x24, 0x27, 0xc7, 0x13, 0x99, 0xee, 0x89, 0xcf, 0x3e, 0x91, 0xb1, 0x8e, 0xcf, 0x3e, 0x99, 0x29,
  	0xd2, 0x8f, 0x27, 0xe4, 0xba, 0xd6, 0x64, 0x79, 0x14, 0x32, 0x53, 0x0f, 0x4a, 0x4a, 0x1a, 0x08,
  	0xa5, 0x10, 0xd3, 0x33, 0xe0, 0xf1, 0x80, 0x97, 0x92, 0x43, 0x32, 0x2f, 0x51, 0x7e, 0xe7, 0x58,
  	0xc0, 0xa3, 0xfc, 0x7a, 0x0c, 0x82, 0x30, 0xe4, 0xb3, 0xe3, 0x3b, 0x3f, 0x65, 0x76, 0xfa, 0xee,
  	0x9f, 0xcb, 0x06, 0xc8, 0x9c, 0x9d, 0xdc, 0xfa, 0xaf, 0xa0, 0xac, 0xa6, 0x7e, 0x50, 0x8a, 0xf0,
  	0xb1, 0x1c, 0x7d, 0x3c, 0x92, 0xa4, 0x65, 0x8e, 0x74, 0xdf, 0x46, 0x59, 0xda, 0x0a, 0x18, 0x61,
  	0xdc, 0x87, 0x02, 0x4f, 0x01, 0xa5, 0xa9, 0x54, 0x4f, 0xe3, 0xa7, 0xa9, 0x34, 0x96, 0x3f, 0xd2,
  	0xcf, 0xcf, 0x94, 0x23, 0xb9, 0x8a, 0x8a, 0x68, 0xcd, 0xb9, 0x3d, 0xc2, 0x61, 0x16, 0x37, 0x99,
  	0xb6, 0xcd, 0xe2, 0xa6, 0x64, 0x08, 0xb2, 0xb8, 0xed, 0xe0, 0x90, 0xfb, 0x03, 0x71, 0xbd, 0x46,
  	0x19, 0xc4, 0xd4, 0x08, 0x69, 0x1e, 0x05, 0x92, 0x76, 0xbd, 0x91, 0x0c, 0x45, 0x78, 0x3c, 0x00,
  	0x90, 0xe9, 0xa8, 0xf8, 0x99, 0x35, 0xb5, 0x52, 0x10, 0x3f, 0xb3, 0xa6, 0x67, 0xb4, 0x74, 0x1f,
  	0x2b, 0xf9, 0xb2, 0xdb, 0x15, 0xe1, 0xfc, 0x85, 0x01, 0x28, 0x99, 0xb0, 0x42, 0xef, 0xa4, 0x53,
  	0x4f, 0xad, 0x3a, 0x34, 0xde, 0x7d, 0x3d, 0xe0, 0x34, 0x87, 0x2c, 0x45, 0xea, 0x52, 0xe8, 0xe1,
  	0x2b, 0x22, 0xd4, 0xe7, 0x06, 0x54, 0xb4, 0x24, 0x17, 0x7a, 0x33, 0xc3, 0xa6, 0xb1, 0xd2, 0x43,
  	0xe3, 0xad, 0x63, 0xe1, 0xd2, 0x0e, 0xf3, 0xca, 0x0a, 0x10, 0xb7, 0x9a, 0xdf, 0x31, 0xa0, 0xaa,
  	0xe7, 0xc2, 0x50, 0x06, 0xed, 0x44, 0xc5, 0xa2, 0x71, 0xf3, 0x78, 0xc0, 0xa3, 0xcd, 0x23, 0x2f,
  	0x34, 0x7d, 0x28, 0xf0, 0xa4, 0x59, 0xda, 0xc2, 0xd7, 0x4b, 0x1c, 0x69, 0x0b, 0x3f, 0x96, 0x71,
  	0x4b, 0x59, 0xf8, 0xbe, 0xd7, 0xc7, 0xca, 0x36, 0xe3, 0xb9, 0xb4, 0x2c, 0x6e, 0x47, 0x6f, 0xb3,
  	0x58, 0x22, 0x2e, 0x8b, 0x9b, 0xdc, 0x66, 0x22, 0x65, 0x86, 0x32, 0x88, 0x1d, 0xb3, 0xcd, 0xe2,
  	0x19, 0xb7, 0x94, 0x6d, 0x46, 0x19, 0x2a, 0xdb, 0x4c, 0xa6, 0xb2, 0xd2, 0xb6, 0x59, 0xa2, 0x1a,
  	0x93, 0xb6, 0xcd, 0x92, 0xd9, 0xb0, 0x14, 0x3b, 0x52, 0xbe, 0xda, 0x36, 0x3b, 0x9b, 0x92, 0xec,
  	0x42, 0xef, 0x66, 0x28, 0x31, 0xb5, 0xb6, 0xd3, 0xb8, 0xfd, 0x9a, 0xd0, 0x99, 0x6b, 0x9c, 0xa9,
  	0x5f, 0xac, 0xf1, 0x3f, 0x32, 0x60, 0x26, 0x2d, 0x3f, 0x86, 0x32, 0xf8, 0x64, 0x94, 0x82, 0x1a,
  	0xf3, 0xaf, 0x0b, 0x7e, 0xb4, 0xb6, 0xa2, 0x55, 0xff, 0x70, 0xe7, 0x8b, 0x56, 0xf3, 0xc5, 0x55,
  	0xb8, 0x02, 0x93, 0xad, 0xa1, 0xf3, 0x04, 0x1f, 0xa2, 0xb3, 0x53, 0xb9, 0x46, 0x85, 0xd0, 0xf5,
  	0x7c, 0xe7, 0x33, 0xfa, 0xab, 0x17, 0x73, 0xb9, 0xed, 0x32, 0x40, 0x04, 0x30, 0xf6, 0xef, 0x5f,
  	0xce, 0x1a, 0xff, 0xf5, 0xe5, 0xac, 0xf1, 0x3f, 0x5f, 0xce, 0x1a, 0x3f, 0xfd, 0xbf, 0xd9, 0xb1,
  	0x17, 0xd7, 0x76, 0x3c, 0x2a, 0xd6, 0xbc, 0xe3, 0x35, 0xe5, 0x2f, 0x71, 0x2c, 0x36, 0x55, 0x51,
  	0xb7, 0x27, 0xe9, 0x4f, 0x67, 0x2c, 0xfe, 0x3c, 0x00, 0x00, 0xff, 0xff, 0x08, 0x5e, 0xc8, 0xca,
  	0xfb, 0x43, 0x00, 0x00,
  }
  
  func (m *ResponseHeader) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *ResponseHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.RaftTerm != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.RaftTerm))
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.Revision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.MemberId != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MemberId))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.ClusterId != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ClusterId))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *RangeRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *RangeRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RangeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.MaxCreateRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MaxCreateRevision))
  		i--
  		dAtA[i] = 0x68
  	}
  	if m.MinCreateRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MinCreateRevision))
  		i--
  		dAtA[i] = 0x60
  	}
  	if m.MaxModRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MaxModRevision))
  		i--
  		dAtA[i] = 0x58
  	}
  	if m.MinModRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MinModRevision))
  		i--
  		dAtA[i] = 0x50
  	}
  	if m.CountOnly {
  		i--
  		if m.CountOnly {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x48
  	}
  	if m.KeysOnly {
  		i--
  		if m.KeysOnly {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x40
  	}
  	if m.Serializable {
  		i--
  		if m.Serializable {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x38
  	}
  	if m.SortTarget != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.SortTarget))
  		i--
  		dAtA[i] = 0x30
  	}
  	if m.SortOrder != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.SortOrder))
  		i--
  		dAtA[i] = 0x28
  	}
  	if m.Revision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.Limit != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Limit))
  		i--
  		dAtA[i] = 0x18
  	}
  	if len(m.RangeEnd) > 0 {
  		i -= len(m.RangeEnd)
  		copy(dAtA[i:], m.RangeEnd)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Key) > 0 {
  		i -= len(m.Key)
  		copy(dAtA[i:], m.Key)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *RangeResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *RangeResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RangeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Count != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Count))
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.More {
  		i--
  		if m.More {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x18
  	}
  	if len(m.Kvs) > 0 {
  		for iNdEx := len(m.Kvs) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Kvs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *PutRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *PutRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *PutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.IgnoreLease {
  		i--
  		if m.IgnoreLease {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x30
  	}
  	if m.IgnoreValue {
  		i--
  		if m.IgnoreValue {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x28
  	}
  	if m.PrevKv {
  		i--
  		if m.PrevKv {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.Lease != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Lease))
  		i--
  		dAtA[i] = 0x18
  	}
  	if len(m.Value) > 0 {
  		i -= len(m.Value)
  		copy(dAtA[i:], m.Value)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Value)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Key) > 0 {
  		i -= len(m.Key)
  		copy(dAtA[i:], m.Key)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *PutResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *PutResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *PutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.PrevKv != nil {
  		{
  			size, err := m.PrevKv.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DeleteRangeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.PrevKv {
  		i--
  		if m.PrevKv {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x18
  	}
  	if len(m.RangeEnd) > 0 {
  		i -= len(m.RangeEnd)
  		copy(dAtA[i:], m.RangeEnd)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Key) > 0 {
  		i -= len(m.Key)
  		copy(dAtA[i:], m.Key)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DeleteRangeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.PrevKvs) > 0 {
  		for iNdEx := len(m.PrevKvs) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.PrevKvs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x1a
  		}
  	}
  	if m.Deleted != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Deleted))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *RequestOp) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *RequestOp) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RequestOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Request != nil {
  		{
  			size := m.Request.Size()
  			i -= size
  			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
  				return 0, err
  			}
  		}
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *RequestOp_RequestRange) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RequestOp_RequestRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.RequestRange != nil {
  		{
  			size, err := m.RequestRange.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  func (m *RequestOp_RequestPut) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RequestOp_RequestPut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.RequestPut != nil {
  		{
  			size, err := m.RequestPut.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x12
  	}
  	return len(dAtA) - i, nil
  }
  func (m *RequestOp_RequestDeleteRange) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RequestOp_RequestDeleteRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.RequestDeleteRange != nil {
  		{
  			size, err := m.RequestDeleteRange.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x1a
  	}
  	return len(dAtA) - i, nil
  }
  func (m *RequestOp_RequestTxn) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *RequestOp_RequestTxn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.RequestTxn != nil {
  		{
  			size, err := m.RequestTxn.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x22
  	}
  	return len(dAtA) - i, nil
  }
  func (m *ResponseOp) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *ResponseOp) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *ResponseOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Response != nil {
  		{
  			size := m.Response.Size()
  			i -= size
  			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
  				return 0, err
  			}
  		}
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *ResponseOp_ResponseRange) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *ResponseOp_ResponseRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.ResponseRange != nil {
  		{
  			size, err := m.ResponseRange.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  func (m *ResponseOp_ResponsePut) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *ResponseOp_ResponsePut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.ResponsePut != nil {
  		{
  			size, err := m.ResponsePut.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x12
  	}
  	return len(dAtA) - i, nil
  }
  func (m *ResponseOp_ResponseDeleteRange) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *ResponseOp_ResponseDeleteRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.ResponseDeleteRange != nil {
  		{
  			size, err := m.ResponseDeleteRange.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x1a
  	}
  	return len(dAtA) - i, nil
  }
  func (m *ResponseOp_ResponseTxn) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *ResponseOp_ResponseTxn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.ResponseTxn != nil {
  		{
  			size, err := m.ResponseTxn.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x22
  	}
  	return len(dAtA) - i, nil
  }
  func (m *Compare) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *Compare) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Compare) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.RangeEnd) > 0 {
  		i -= len(m.RangeEnd)
  		copy(dAtA[i:], m.RangeEnd)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
  		i--
  		dAtA[i] = 0x4
  		i--
  		dAtA[i] = 0x82
  	}
  	if m.TargetUnion != nil {
  		{
  			size := m.TargetUnion.Size()
  			i -= size
  			if _, err := m.TargetUnion.MarshalTo(dAtA[i:]); err != nil {
  				return 0, err
  			}
  		}
  	}
  	if len(m.Key) > 0 {
  		i -= len(m.Key)
  		copy(dAtA[i:], m.Key)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
  		i--
  		dAtA[i] = 0x1a
  	}
  	if m.Target != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Target))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Result != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Result))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *Compare_Version) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Compare_Version) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	i = encodeVarintRpc(dAtA, i, uint64(m.Version))
  	i--
  	dAtA[i] = 0x20
  	return len(dAtA) - i, nil
  }
  func (m *Compare_CreateRevision) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Compare_CreateRevision) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	i = encodeVarintRpc(dAtA, i, uint64(m.CreateRevision))
  	i--
  	dAtA[i] = 0x28
  	return len(dAtA) - i, nil
  }
  func (m *Compare_ModRevision) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Compare_ModRevision) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	i = encodeVarintRpc(dAtA, i, uint64(m.ModRevision))
  	i--
  	dAtA[i] = 0x30
  	return len(dAtA) - i, nil
  }
  func (m *Compare_Value) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Compare_Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.Value != nil {
  		i -= len(m.Value)
  		copy(dAtA[i:], m.Value)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Value)))
  		i--
  		dAtA[i] = 0x3a
  	}
  	return len(dAtA) - i, nil
  }
  func (m *Compare_Lease) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Compare_Lease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	i = encodeVarintRpc(dAtA, i, uint64(m.Lease))
  	i--
  	dAtA[i] = 0x40
  	return len(dAtA) - i, nil
  }
  func (m *TxnRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *TxnRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *TxnRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Failure) > 0 {
  		for iNdEx := len(m.Failure) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Failure[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x1a
  		}
  	}
  	if len(m.Success) > 0 {
  		for iNdEx := len(m.Success) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Success[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if len(m.Compare) > 0 {
  		for iNdEx := len(m.Compare) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Compare[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0xa
  		}
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *TxnResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *TxnResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *TxnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Responses) > 0 {
  		for iNdEx := len(m.Responses) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Responses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x1a
  		}
  	}
  	if m.Succeeded {
  		i--
  		if m.Succeeded {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *CompactionRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *CompactionRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *CompactionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Physical {
  		i--
  		if m.Physical {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Revision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *CompactionResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *CompactionResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *CompactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *HashRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *HashRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *HashRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *HashKVRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *HashKVRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *HashKVRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Revision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *HashKVResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *HashKVResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *HashKVResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.HashRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.HashRevision))
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.CompactRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.CompactRevision))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.Hash != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Hash))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *HashResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *HashResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *HashResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Hash != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Hash))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *SnapshotRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *SnapshotRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *SnapshotRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *SnapshotResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *SnapshotResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *SnapshotResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Version) > 0 {
  		i -= len(m.Version)
  		copy(dAtA[i:], m.Version)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Version)))
  		i--
  		dAtA[i] = 0x22
  	}
  	if len(m.Blob) > 0 {
  		i -= len(m.Blob)
  		copy(dAtA[i:], m.Blob)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Blob)))
  		i--
  		dAtA[i] = 0x1a
  	}
  	if m.RemainingBytes != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.RemainingBytes))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *WatchRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *WatchRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.RequestUnion != nil {
  		{
  			size := m.RequestUnion.Size()
  			i -= size
  			if _, err := m.RequestUnion.MarshalTo(dAtA[i:]); err != nil {
  				return 0, err
  			}
  		}
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *WatchRequest_CreateRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchRequest_CreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.CreateRequest != nil {
  		{
  			size, err := m.CreateRequest.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  func (m *WatchRequest_CancelRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchRequest_CancelRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.CancelRequest != nil {
  		{
  			size, err := m.CancelRequest.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x12
  	}
  	return len(dAtA) - i, nil
  }
  func (m *WatchRequest_ProgressRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchRequest_ProgressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	if m.ProgressRequest != nil {
  		{
  			size, err := m.ProgressRequest.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x1a
  	}
  	return len(dAtA) - i, nil
  }
  func (m *WatchCreateRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *WatchCreateRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Fragment {
  		i--
  		if m.Fragment {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x40
  	}
  	if m.WatchId != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.WatchId))
  		i--
  		dAtA[i] = 0x38
  	}
  	if m.PrevKv {
  		i--
  		if m.PrevKv {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x30
  	}
  	if len(m.Filters) > 0 {
  		dAtA22 := make([]byte, len(m.Filters)*10)
  		var j21 int
  		for _, num := range m.Filters {
  			for num >= 1<<7 {
  				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
  				num >>= 7
  				j21++
  			}
  			dAtA22[j21] = uint8(num)
  			j21++
  		}
  		i -= j21
  		copy(dAtA[i:], dAtA22[:j21])
  		i = encodeVarintRpc(dAtA, i, uint64(j21))
  		i--
  		dAtA[i] = 0x2a
  	}
  	if m.ProgressNotify {
  		i--
  		if m.ProgressNotify {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.StartRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.StartRevision))
  		i--
  		dAtA[i] = 0x18
  	}
  	if len(m.RangeEnd) > 0 {
  		i -= len(m.RangeEnd)
  		copy(dAtA[i:], m.RangeEnd)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Key) > 0 {
  		i -= len(m.Key)
  		copy(dAtA[i:], m.Key)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *WatchCancelRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *WatchCancelRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchCancelRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.WatchId != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.WatchId))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *WatchProgressRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *WatchProgressRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchProgressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *WatchResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *WatchResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *WatchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Events) > 0 {
  		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x5a
  		}
  	}
  	if m.Fragment {
  		i--
  		if m.Fragment {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x38
  	}
  	if len(m.CancelReason) > 0 {
  		i -= len(m.CancelReason)
  		copy(dAtA[i:], m.CancelReason)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.CancelReason)))
  		i--
  		dAtA[i] = 0x32
  	}
  	if m.CompactRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.CompactRevision))
  		i--
  		dAtA[i] = 0x28
  	}
  	if m.Canceled {
  		i--
  		if m.Canceled {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.Created {
  		i--
  		if m.Created {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.WatchId != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.WatchId))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseGrantRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseGrantRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseGrantRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.TTL != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseGrantResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseGrantResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseGrantResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Error) > 0 {
  		i -= len(m.Error)
  		copy(dAtA[i:], m.Error)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Error)))
  		i--
  		dAtA[i] = 0x22
  	}
  	if m.TTL != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseRevokeRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseRevokeRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseRevokeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseRevokeResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseRevokeResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseRevokeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseCheckpoint) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseCheckpoint) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseCheckpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Remaining_TTL != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Remaining_TTL))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseCheckpointRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseCheckpointRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseCheckpointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Checkpoints) > 0 {
  		for iNdEx := len(m.Checkpoints) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Checkpoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0xa
  		}
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseCheckpointResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseCheckpointResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseCheckpointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseKeepAliveRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseKeepAliveRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseKeepAliveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseKeepAliveResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseKeepAliveResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseKeepAliveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.TTL != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseTimeToLiveRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseTimeToLiveRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseTimeToLiveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Keys {
  		i--
  		if m.Keys {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseTimeToLiveResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseTimeToLiveResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseTimeToLiveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Keys) > 0 {
  		for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.Keys[iNdEx])
  			copy(dAtA[i:], m.Keys[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.Keys[iNdEx])))
  			i--
  			dAtA[i] = 0x2a
  		}
  	}
  	if m.GrantedTTL != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.GrantedTTL))
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.TTL != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseLeasesRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseLeasesRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseLeasesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseStatus) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseStatus) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *LeaseLeasesResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *LeaseLeasesResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *LeaseLeasesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Leases) > 0 {
  		for iNdEx := len(m.Leases) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Leases[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *Member) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *Member) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.IsLearner {
  		i--
  		if m.IsLearner {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x28
  	}
  	if len(m.ClientURLs) > 0 {
  		for iNdEx := len(m.ClientURLs) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.ClientURLs[iNdEx])
  			copy(dAtA[i:], m.ClientURLs[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.ClientURLs[iNdEx])))
  			i--
  			dAtA[i] = 0x22
  		}
  	}
  	if len(m.PeerURLs) > 0 {
  		for iNdEx := len(m.PeerURLs) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.PeerURLs[iNdEx])
  			copy(dAtA[i:], m.PeerURLs[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.PeerURLs[iNdEx])))
  			i--
  			dAtA[i] = 0x1a
  		}
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberAddRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberAddRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.IsLearner {
  		i--
  		if m.IsLearner {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x10
  	}
  	if len(m.PeerURLs) > 0 {
  		for iNdEx := len(m.PeerURLs) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.PeerURLs[iNdEx])
  			copy(dAtA[i:], m.PeerURLs[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.PeerURLs[iNdEx])))
  			i--
  			dAtA[i] = 0xa
  		}
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberAddResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberAddResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Members) > 0 {
  		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x1a
  		}
  	}
  	if m.Member != nil {
  		{
  			size, err := m.Member.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberRemoveRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberRemoveRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberRemoveRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberRemoveResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberRemoveResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberRemoveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Members) > 0 {
  		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberUpdateRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.PeerURLs) > 0 {
  		for iNdEx := len(m.PeerURLs) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.PeerURLs[iNdEx])
  			copy(dAtA[i:], m.PeerURLs[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.PeerURLs[iNdEx])))
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberUpdateResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Members) > 0 {
  		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberListRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberListRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Linearizable {
  		i--
  		if m.Linearizable {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberListResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberListResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Members) > 0 {
  		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberPromoteRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberPromoteRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberPromoteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.ID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MemberPromoteResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MemberPromoteResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MemberPromoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Members) > 0 {
  		for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DefragmentRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DefragmentRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DefragmentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DefragmentResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DefragmentResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DefragmentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MoveLeaderRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MoveLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MoveLeaderRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.TargetID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.TargetID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *MoveLeaderResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *MoveLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *MoveLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AlarmRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AlarmRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AlarmRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Alarm != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Alarm))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.MemberID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MemberID))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Action != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Action))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AlarmMember) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AlarmMember) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AlarmMember) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Alarm != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Alarm))
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.MemberID != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.MemberID))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AlarmResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AlarmResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AlarmResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Alarms) > 0 {
  		for iNdEx := len(m.Alarms) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Alarms[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DowngradeRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DowngradeRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DowngradeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Version) > 0 {
  		i -= len(m.Version)
  		copy(dAtA[i:], m.Version)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Version)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Action != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Action))
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DowngradeResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DowngradeResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DowngradeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Version) > 0 {
  		i -= len(m.Version)
  		copy(dAtA[i:], m.Version)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Version)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DowngradeVersionTestRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DowngradeVersionTestRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DowngradeVersionTestRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Ver) > 0 {
  		i -= len(m.Ver)
  		copy(dAtA[i:], m.Ver)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Ver)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *StatusRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *StatusResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *StatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.DowngradeInfo != nil {
  		{
  			size, err := m.DowngradeInfo.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x6a
  	}
  	if m.DbSizeQuota != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.DbSizeQuota))
  		i--
  		dAtA[i] = 0x60
  	}
  	if len(m.StorageVersion) > 0 {
  		i -= len(m.StorageVersion)
  		copy(dAtA[i:], m.StorageVersion)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.StorageVersion)))
  		i--
  		dAtA[i] = 0x5a
  	}
  	if m.IsLearner {
  		i--
  		if m.IsLearner {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x50
  	}
  	if m.DbSizeInUse != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.DbSizeInUse))
  		i--
  		dAtA[i] = 0x48
  	}
  	if len(m.Errors) > 0 {
  		for iNdEx := len(m.Errors) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.Errors[iNdEx])
  			copy(dAtA[i:], m.Errors[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.Errors[iNdEx])))
  			i--
  			dAtA[i] = 0x42
  		}
  	}
  	if m.RaftAppliedIndex != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.RaftAppliedIndex))
  		i--
  		dAtA[i] = 0x38
  	}
  	if m.RaftTerm != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.RaftTerm))
  		i--
  		dAtA[i] = 0x30
  	}
  	if m.RaftIndex != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.RaftIndex))
  		i--
  		dAtA[i] = 0x28
  	}
  	if m.Leader != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.Leader))
  		i--
  		dAtA[i] = 0x20
  	}
  	if m.DbSize != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.DbSize))
  		i--
  		dAtA[i] = 0x18
  	}
  	if len(m.Version) > 0 {
  		i -= len(m.Version)
  		copy(dAtA[i:], m.Version)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Version)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *DowngradeInfo) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *DowngradeInfo) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *DowngradeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.TargetVersion) > 0 {
  		i -= len(m.TargetVersion)
  		copy(dAtA[i:], m.TargetVersion)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.TargetVersion)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Enabled {
  		i--
  		if m.Enabled {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x8
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthEnableRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthEnableRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthEnableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthDisableRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthDisableRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthDisableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthStatusRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthStatusRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthenticateRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthenticateRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthenticateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Password) > 0 {
  		i -= len(m.Password)
  		copy(dAtA[i:], m.Password)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Password)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserAddRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserAddRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.HashedPassword) > 0 {
  		i -= len(m.HashedPassword)
  		copy(dAtA[i:], m.HashedPassword)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.HashedPassword)))
  		i--
  		dAtA[i] = 0x22
  	}
  	if m.Options != nil {
  		{
  			size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x1a
  	}
  	if len(m.Password) > 0 {
  		i -= len(m.Password)
  		copy(dAtA[i:], m.Password)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Password)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserGetRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserGetRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserDeleteRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserChangePasswordRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserChangePasswordRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserChangePasswordRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.HashedPassword) > 0 {
  		i -= len(m.HashedPassword)
  		copy(dAtA[i:], m.HashedPassword)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.HashedPassword)))
  		i--
  		dAtA[i] = 0x1a
  	}
  	if len(m.Password) > 0 {
  		i -= len(m.Password)
  		copy(dAtA[i:], m.Password)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Password)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserGrantRoleRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserGrantRoleRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserGrantRoleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Role) > 0 {
  		i -= len(m.Role)
  		copy(dAtA[i:], m.Role)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.User) > 0 {
  		i -= len(m.User)
  		copy(dAtA[i:], m.User)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.User)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserRevokeRoleRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserRevokeRoleRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserRevokeRoleRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Role) > 0 {
  		i -= len(m.Role)
  		copy(dAtA[i:], m.Role)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleAddRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleAddRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleGetRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleGetRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Role) > 0 {
  		i -= len(m.Role)
  		copy(dAtA[i:], m.Role)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserListRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserListRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleListRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleListRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleListRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleDeleteRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Role) > 0 {
  		i -= len(m.Role)
  		copy(dAtA[i:], m.Role)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleGrantPermissionRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleGrantPermissionRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleGrantPermissionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Perm != nil {
  		{
  			size, err := m.Perm.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Name) > 0 {
  		i -= len(m.Name)
  		copy(dAtA[i:], m.Name)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleRevokePermissionRequest) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleRevokePermissionRequest) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleRevokePermissionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.RangeEnd) > 0 {
  		i -= len(m.RangeEnd)
  		copy(dAtA[i:], m.RangeEnd)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
  		i--
  		dAtA[i] = 0x1a
  	}
  	if len(m.Key) > 0 {
  		i -= len(m.Key)
  		copy(dAtA[i:], m.Key)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if len(m.Role) > 0 {
  		i -= len(m.Role)
  		copy(dAtA[i:], m.Role)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthEnableResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthEnableResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthEnableResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthDisableResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthDisableResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthDisableResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthStatusResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthStatusResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.AuthRevision != 0 {
  		i = encodeVarintRpc(dAtA, i, uint64(m.AuthRevision))
  		i--
  		dAtA[i] = 0x18
  	}
  	if m.Enabled {
  		i--
  		if m.Enabled {
  			dAtA[i] = 1
  		} else {
  			dAtA[i] = 0
  		}
  		i--
  		dAtA[i] = 0x10
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthenticateResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthenticateResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthenticateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Token) > 0 {
  		i -= len(m.Token)
  		copy(dAtA[i:], m.Token)
  		i = encodeVarintRpc(dAtA, i, uint64(len(m.Token)))
  		i--
  		dAtA[i] = 0x12
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserAddResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserAddResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserGetResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserGetResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Roles) > 0 {
  		for iNdEx := len(m.Roles) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.Roles[iNdEx])
  			copy(dAtA[i:], m.Roles[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.Roles[iNdEx])))
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserDeleteResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserChangePasswordResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserChangePasswordResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserChangePasswordResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserGrantRoleResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserGrantRoleResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserGrantRoleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserRevokeRoleResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserRevokeRoleResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserRevokeRoleResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleAddResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleAddResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleAddResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleGetResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleGetResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Perm) > 0 {
  		for iNdEx := len(m.Perm) - 1; iNdEx >= 0; iNdEx-- {
  			{
  				size, err := m.Perm[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  				if err != nil {
  					return 0, err
  				}
  				i -= size
  				i = encodeVarintRpc(dAtA, i, uint64(size))
  			}
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleListResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleListResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Roles) > 0 {
  		for iNdEx := len(m.Roles) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.Roles[iNdEx])
  			copy(dAtA[i:], m.Roles[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.Roles[iNdEx])))
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthUserListResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthUserListResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthUserListResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if len(m.Users) > 0 {
  		for iNdEx := len(m.Users) - 1; iNdEx >= 0; iNdEx-- {
  			i -= len(m.Users[iNdEx])
  			copy(dAtA[i:], m.Users[iNdEx])
  			i = encodeVarintRpc(dAtA, i, uint64(len(m.Users[iNdEx])))
  			i--
  			dAtA[i] = 0x12
  		}
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleDeleteResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleGrantPermissionResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleGrantPermissionResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleGrantPermissionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func (m *AuthRoleRevokePermissionResponse) Marshal() (dAtA []byte, err error) {
  	size := m.Size()
  	dAtA = make([]byte, size)
  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  	if err != nil {
  		return nil, err
  	}
  	return dAtA[:n], nil
  }
  
  func (m *AuthRoleRevokePermissionResponse) MarshalTo(dAtA []byte) (int, error) {
  	size := m.Size()
  	return m.MarshalToSizedBuffer(dAtA[:size])
  }
  
  func (m *AuthRoleRevokePermissionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  	i := len(dAtA)
  	_ = i
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		i -= len(m.XXX_unrecognized)
  		copy(dAtA[i:], m.XXX_unrecognized)
  	}
  	if m.Header != nil {
  		{
  			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
  			if err != nil {
  				return 0, err
  			}
  			i -= size
  			i = encodeVarintRpc(dAtA, i, uint64(size))
  		}
  		i--
  		dAtA[i] = 0xa
  	}
  	return len(dAtA) - i, nil
  }
  
  func encodeVarintRpc(dAtA []byte, offset int, v uint64) int {
  	offset -= sovRpc(v)
  	base := offset
  	for v >= 1<<7 {
  		dAtA[offset] = uint8(v&0x7f | 0x80)
  		v >>= 7
  		offset++
  	}
  	dAtA[offset] = uint8(v)
  	return base
  }
  func (m *ResponseHeader) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ClusterId != 0 {
  		n += 1 + sovRpc(uint64(m.ClusterId))
  	}
  	if m.MemberId != 0 {
  		n += 1 + sovRpc(uint64(m.MemberId))
  	}
  	if m.Revision != 0 {
  		n += 1 + sovRpc(uint64(m.Revision))
  	}
  	if m.RaftTerm != 0 {
  		n += 1 + sovRpc(uint64(m.RaftTerm))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *RangeRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Key)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.RangeEnd)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Limit != 0 {
  		n += 1 + sovRpc(uint64(m.Limit))
  	}
  	if m.Revision != 0 {
  		n += 1 + sovRpc(uint64(m.Revision))
  	}
  	if m.SortOrder != 0 {
  		n += 1 + sovRpc(uint64(m.SortOrder))
  	}
  	if m.SortTarget != 0 {
  		n += 1 + sovRpc(uint64(m.SortTarget))
  	}
  	if m.Serializable {
  		n += 2
  	}
  	if m.KeysOnly {
  		n += 2
  	}
  	if m.CountOnly {
  		n += 2
  	}
  	if m.MinModRevision != 0 {
  		n += 1 + sovRpc(uint64(m.MinModRevision))
  	}
  	if m.MaxModRevision != 0 {
  		n += 1 + sovRpc(uint64(m.MaxModRevision))
  	}
  	if m.MinCreateRevision != 0 {
  		n += 1 + sovRpc(uint64(m.MinCreateRevision))
  	}
  	if m.MaxCreateRevision != 0 {
  		n += 1 + sovRpc(uint64(m.MaxCreateRevision))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *RangeResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Kvs) > 0 {
  		for _, e := range m.Kvs {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.More {
  		n += 2
  	}
  	if m.Count != 0 {
  		n += 1 + sovRpc(uint64(m.Count))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *PutRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Key)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Value)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Lease != 0 {
  		n += 1 + sovRpc(uint64(m.Lease))
  	}
  	if m.PrevKv {
  		n += 2
  	}
  	if m.IgnoreValue {
  		n += 2
  	}
  	if m.IgnoreLease {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *PutResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.PrevKv != nil {
  		l = m.PrevKv.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DeleteRangeRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Key)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.RangeEnd)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.PrevKv {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DeleteRangeResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Deleted != 0 {
  		n += 1 + sovRpc(uint64(m.Deleted))
  	}
  	if len(m.PrevKvs) > 0 {
  		for _, e := range m.PrevKvs {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *RequestOp) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Request != nil {
  		n += m.Request.Size()
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *RequestOp_RequestRange) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.RequestRange != nil {
  		l = m.RequestRange.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *RequestOp_RequestPut) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.RequestPut != nil {
  		l = m.RequestPut.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *RequestOp_RequestDeleteRange) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.RequestDeleteRange != nil {
  		l = m.RequestDeleteRange.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *RequestOp_RequestTxn) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.RequestTxn != nil {
  		l = m.RequestTxn.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *ResponseOp) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Response != nil {
  		n += m.Response.Size()
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *ResponseOp_ResponseRange) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ResponseRange != nil {
  		l = m.ResponseRange.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *ResponseOp_ResponsePut) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ResponsePut != nil {
  		l = m.ResponsePut.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *ResponseOp_ResponseDeleteRange) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ResponseDeleteRange != nil {
  		l = m.ResponseDeleteRange.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *ResponseOp_ResponseTxn) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ResponseTxn != nil {
  		l = m.ResponseTxn.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *Compare) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Result != 0 {
  		n += 1 + sovRpc(uint64(m.Result))
  	}
  	if m.Target != 0 {
  		n += 1 + sovRpc(uint64(m.Target))
  	}
  	l = len(m.Key)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.TargetUnion != nil {
  		n += m.TargetUnion.Size()
  	}
  	l = len(m.RangeEnd)
  	if l > 0 {
  		n += 2 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *Compare_Version) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	n += 1 + sovRpc(uint64(m.Version))
  	return n
  }
  func (m *Compare_CreateRevision) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	n += 1 + sovRpc(uint64(m.CreateRevision))
  	return n
  }
  func (m *Compare_ModRevision) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	n += 1 + sovRpc(uint64(m.ModRevision))
  	return n
  }
  func (m *Compare_Value) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Value != nil {
  		l = len(m.Value)
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *Compare_Lease) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	n += 1 + sovRpc(uint64(m.Lease))
  	return n
  }
  func (m *TxnRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if len(m.Compare) > 0 {
  		for _, e := range m.Compare {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if len(m.Success) > 0 {
  		for _, e := range m.Success {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if len(m.Failure) > 0 {
  		for _, e := range m.Failure {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *TxnResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Succeeded {
  		n += 2
  	}
  	if len(m.Responses) > 0 {
  		for _, e := range m.Responses {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *CompactionRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Revision != 0 {
  		n += 1 + sovRpc(uint64(m.Revision))
  	}
  	if m.Physical {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *CompactionResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *HashRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *HashKVRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Revision != 0 {
  		n += 1 + sovRpc(uint64(m.Revision))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *HashKVResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Hash != 0 {
  		n += 1 + sovRpc(uint64(m.Hash))
  	}
  	if m.CompactRevision != 0 {
  		n += 1 + sovRpc(uint64(m.CompactRevision))
  	}
  	if m.HashRevision != 0 {
  		n += 1 + sovRpc(uint64(m.HashRevision))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *HashResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Hash != 0 {
  		n += 1 + sovRpc(uint64(m.Hash))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *SnapshotRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *SnapshotResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.RemainingBytes != 0 {
  		n += 1 + sovRpc(uint64(m.RemainingBytes))
  	}
  	l = len(m.Blob)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Version)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *WatchRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.RequestUnion != nil {
  		n += m.RequestUnion.Size()
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *WatchRequest_CreateRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.CreateRequest != nil {
  		l = m.CreateRequest.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *WatchRequest_CancelRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.CancelRequest != nil {
  		l = m.CancelRequest.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *WatchRequest_ProgressRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ProgressRequest != nil {
  		l = m.ProgressRequest.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	return n
  }
  func (m *WatchCreateRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Key)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.RangeEnd)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.StartRevision != 0 {
  		n += 1 + sovRpc(uint64(m.StartRevision))
  	}
  	if m.ProgressNotify {
  		n += 2
  	}
  	if len(m.Filters) > 0 {
  		l = 0
  		for _, e := range m.Filters {
  			l += sovRpc(uint64(e))
  		}
  		n += 1 + sovRpc(uint64(l)) + l
  	}
  	if m.PrevKv {
  		n += 2
  	}
  	if m.WatchId != 0 {
  		n += 1 + sovRpc(uint64(m.WatchId))
  	}
  	if m.Fragment {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *WatchCancelRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.WatchId != 0 {
  		n += 1 + sovRpc(uint64(m.WatchId))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *WatchProgressRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *WatchResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.WatchId != 0 {
  		n += 1 + sovRpc(uint64(m.WatchId))
  	}
  	if m.Created {
  		n += 2
  	}
  	if m.Canceled {
  		n += 2
  	}
  	if m.CompactRevision != 0 {
  		n += 1 + sovRpc(uint64(m.CompactRevision))
  	}
  	l = len(m.CancelReason)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Fragment {
  		n += 2
  	}
  	if len(m.Events) > 0 {
  		for _, e := range m.Events {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseGrantRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.TTL != 0 {
  		n += 1 + sovRpc(uint64(m.TTL))
  	}
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseGrantResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.TTL != 0 {
  		n += 1 + sovRpc(uint64(m.TTL))
  	}
  	l = len(m.Error)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseRevokeRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseRevokeResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseCheckpoint) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.Remaining_TTL != 0 {
  		n += 1 + sovRpc(uint64(m.Remaining_TTL))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseCheckpointRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if len(m.Checkpoints) > 0 {
  		for _, e := range m.Checkpoints {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseCheckpointResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseKeepAliveRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseKeepAliveResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.TTL != 0 {
  		n += 1 + sovRpc(uint64(m.TTL))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseTimeToLiveRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.Keys {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseTimeToLiveResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.TTL != 0 {
  		n += 1 + sovRpc(uint64(m.TTL))
  	}
  	if m.GrantedTTL != 0 {
  		n += 1 + sovRpc(uint64(m.GrantedTTL))
  	}
  	if len(m.Keys) > 0 {
  		for _, b := range m.Keys {
  			l = len(b)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseLeasesRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseStatus) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *LeaseLeasesResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Leases) > 0 {
  		for _, e := range m.Leases {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *Member) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.PeerURLs) > 0 {
  		for _, s := range m.PeerURLs {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if len(m.ClientURLs) > 0 {
  		for _, s := range m.ClientURLs {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.IsLearner {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberAddRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if len(m.PeerURLs) > 0 {
  		for _, s := range m.PeerURLs {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.IsLearner {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberAddResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Member != nil {
  		l = m.Member.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Members) > 0 {
  		for _, e := range m.Members {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberRemoveRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberRemoveResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Members) > 0 {
  		for _, e := range m.Members {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberUpdateRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if len(m.PeerURLs) > 0 {
  		for _, s := range m.PeerURLs {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberUpdateResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Members) > 0 {
  		for _, e := range m.Members {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberListRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Linearizable {
  		n += 2
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberListResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Members) > 0 {
  		for _, e := range m.Members {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberPromoteRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.ID != 0 {
  		n += 1 + sovRpc(uint64(m.ID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MemberPromoteResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Members) > 0 {
  		for _, e := range m.Members {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DefragmentRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DefragmentResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MoveLeaderRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.TargetID != 0 {
  		n += 1 + sovRpc(uint64(m.TargetID))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *MoveLeaderResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AlarmRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Action != 0 {
  		n += 1 + sovRpc(uint64(m.Action))
  	}
  	if m.MemberID != 0 {
  		n += 1 + sovRpc(uint64(m.MemberID))
  	}
  	if m.Alarm != 0 {
  		n += 1 + sovRpc(uint64(m.Alarm))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AlarmMember) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.MemberID != 0 {
  		n += 1 + sovRpc(uint64(m.MemberID))
  	}
  	if m.Alarm != 0 {
  		n += 1 + sovRpc(uint64(m.Alarm))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AlarmResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Alarms) > 0 {
  		for _, e := range m.Alarms {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DowngradeRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Action != 0 {
  		n += 1 + sovRpc(uint64(m.Action))
  	}
  	l = len(m.Version)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DowngradeResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Version)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DowngradeVersionTestRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Ver)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *StatusRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *StatusResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Version)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.DbSize != 0 {
  		n += 1 + sovRpc(uint64(m.DbSize))
  	}
  	if m.Leader != 0 {
  		n += 1 + sovRpc(uint64(m.Leader))
  	}
  	if m.RaftIndex != 0 {
  		n += 1 + sovRpc(uint64(m.RaftIndex))
  	}
  	if m.RaftTerm != 0 {
  		n += 1 + sovRpc(uint64(m.RaftTerm))
  	}
  	if m.RaftAppliedIndex != 0 {
  		n += 1 + sovRpc(uint64(m.RaftAppliedIndex))
  	}
  	if len(m.Errors) > 0 {
  		for _, s := range m.Errors {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.DbSizeInUse != 0 {
  		n += 1 + sovRpc(uint64(m.DbSizeInUse))
  	}
  	if m.IsLearner {
  		n += 2
  	}
  	l = len(m.StorageVersion)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.DbSizeQuota != 0 {
  		n += 1 + sovRpc(uint64(m.DbSizeQuota))
  	}
  	if m.DowngradeInfo != nil {
  		l = m.DowngradeInfo.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *DowngradeInfo) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Enabled {
  		n += 2
  	}
  	l = len(m.TargetVersion)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthEnableRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthDisableRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthStatusRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthenticateRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Password)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserAddRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Password)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Options != nil {
  		l = m.Options.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.HashedPassword)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserGetRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserDeleteRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserChangePasswordRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Password)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.HashedPassword)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserGrantRoleRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.User)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Role)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserRevokeRoleRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Role)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleAddRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleGetRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Role)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserListRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleListRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleDeleteRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Role)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleGrantPermissionRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Name)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Perm != nil {
  		l = m.Perm.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleRevokePermissionRequest) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	l = len(m.Role)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Key)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.RangeEnd)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthEnableResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthDisableResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthStatusResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.Enabled {
  		n += 2
  	}
  	if m.AuthRevision != 0 {
  		n += 1 + sovRpc(uint64(m.AuthRevision))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthenticateResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	l = len(m.Token)
  	if l > 0 {
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserAddResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserGetResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Roles) > 0 {
  		for _, s := range m.Roles {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserDeleteResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserChangePasswordResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserGrantRoleResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserRevokeRoleResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleAddResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleGetResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Perm) > 0 {
  		for _, e := range m.Perm {
  			l = e.Size()
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleListResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Roles) > 0 {
  		for _, s := range m.Roles {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthUserListResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if len(m.Users) > 0 {
  		for _, s := range m.Users {
  			l = len(s)
  			n += 1 + l + sovRpc(uint64(l))
  		}
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleDeleteResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleGrantPermissionResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func (m *AuthRoleRevokePermissionResponse) Size() (n int) {
  	if m == nil {
  		return 0
  	}
  	var l int
  	_ = l
  	if m.Header != nil {
  		l = m.Header.Size()
  		n += 1 + l + sovRpc(uint64(l))
  	}
  	if m.XXX_unrecognized != nil {
  		n += len(m.XXX_unrecognized)
  	}
  	return n
  }
  
  func sovRpc(x uint64) (n int) {
  	return (math_bits.Len64(x|1) + 6) / 7
  }
  func sozRpc(x uint64) (n int) {
  	return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  }
  func (m *ResponseHeader) 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 ErrIntOverflowRpc
  			}
  			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: ResponseHeader: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
  			}
  			m.ClusterId = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ClusterId |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType)
  			}
  			m.MemberId = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MemberId |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
  			}
  			m.Revision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Revision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType)
  			}
  			m.RaftTerm = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.RaftTerm |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *RangeRequest) 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 ErrIntOverflowRpc
  			}
  			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: RangeRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: RangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  			if m.Key == nil {
  				m.Key = []byte{}
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
  			if m.RangeEnd == nil {
  				m.RangeEnd = []byte{}
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
  			}
  			m.Limit = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Limit |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
  			}
  			m.Revision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Revision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 5:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field SortOrder", wireType)
  			}
  			m.SortOrder = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.SortOrder |= RangeRequest_SortOrder(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 6:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field SortTarget", wireType)
  			}
  			m.SortTarget = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.SortTarget |= RangeRequest_SortTarget(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 7:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Serializable", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Serializable = bool(v != 0)
  		case 8:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field KeysOnly", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.KeysOnly = bool(v != 0)
  		case 9:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CountOnly", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.CountOnly = bool(v != 0)
  		case 10:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MinModRevision", wireType)
  			}
  			m.MinModRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MinModRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 11:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MaxModRevision", wireType)
  			}
  			m.MaxModRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MaxModRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 12:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MinCreateRevision", wireType)
  			}
  			m.MinCreateRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MinCreateRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 13:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MaxCreateRevision", wireType)
  			}
  			m.MaxCreateRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MaxCreateRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *RangeResponse) 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 ErrIntOverflowRpc
  			}
  			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: RangeResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: RangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Kvs = append(m.Kvs, &mvccpb.KeyValue{})
  			if err := m.Kvs[len(m.Kvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field More", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.More = bool(v != 0)
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
  			}
  			m.Count = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Count |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *PutRequest) 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 ErrIntOverflowRpc
  			}
  			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: PutRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: PutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  			if m.Key == nil {
  				m.Key = []byte{}
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
  			if m.Value == nil {
  				m.Value = []byte{}
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
  			}
  			m.Lease = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Lease |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.PrevKv = bool(v != 0)
  		case 5:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreValue", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.IgnoreValue = bool(v != 0)
  		case 6:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreLease", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.IgnoreLease = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *PutResponse) 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 ErrIntOverflowRpc
  			}
  			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: PutResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: PutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.PrevKv == nil {
  				m.PrevKv = &mvccpb.KeyValue{}
  			}
  			if err := m.PrevKv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DeleteRangeRequest) 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 ErrIntOverflowRpc
  			}
  			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: DeleteRangeRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  			if m.Key == nil {
  				m.Key = []byte{}
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
  			if m.RangeEnd == nil {
  				m.RangeEnd = []byte{}
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.PrevKv = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DeleteRangeResponse) 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 ErrIntOverflowRpc
  			}
  			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: DeleteRangeResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
  			}
  			m.Deleted = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Deleted |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PrevKvs", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.PrevKvs = append(m.PrevKvs, &mvccpb.KeyValue{})
  			if err := m.PrevKvs[len(m.PrevKvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *RequestOp) 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 ErrIntOverflowRpc
  			}
  			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: RequestOp: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: RequestOp: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RequestRange", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &RangeRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Request = &RequestOp_RequestRange{v}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RequestPut", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &PutRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Request = &RequestOp_RequestPut{v}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RequestDeleteRange", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &DeleteRangeRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Request = &RequestOp_RequestDeleteRange{v}
  			iNdEx = postIndex
  		case 4:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RequestTxn", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &TxnRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Request = &RequestOp_RequestTxn{v}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *ResponseOp) 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 ErrIntOverflowRpc
  			}
  			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: ResponseOp: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: ResponseOp: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ResponseRange", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &RangeResponse{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Response = &ResponseOp_ResponseRange{v}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ResponsePut", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &PutResponse{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Response = &ResponseOp_ResponsePut{v}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ResponseDeleteRange", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &DeleteRangeResponse{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Response = &ResponseOp_ResponseDeleteRange{v}
  			iNdEx = postIndex
  		case 4:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ResponseTxn", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &TxnResponse{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.Response = &ResponseOp_ResponseTxn{v}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *Compare) 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 ErrIntOverflowRpc
  			}
  			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: Compare: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: Compare: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
  			}
  			m.Result = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Result |= Compare_CompareResult(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
  			}
  			m.Target = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Target |= Compare_CompareTarget(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  			if m.Key == nil {
  				m.Key = []byte{}
  			}
  			iNdEx = postIndex
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  			}
  			var v int64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.TargetUnion = &Compare_Version{v}
  		case 5:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CreateRevision", wireType)
  			}
  			var v int64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.TargetUnion = &Compare_CreateRevision{v}
  		case 6:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ModRevision", wireType)
  			}
  			var v int64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.TargetUnion = &Compare_ModRevision{v}
  		case 7:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := make([]byte, postIndex-iNdEx)
  			copy(v, dAtA[iNdEx:postIndex])
  			m.TargetUnion = &Compare_Value{v}
  			iNdEx = postIndex
  		case 8:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
  			}
  			var v int64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.TargetUnion = &Compare_Lease{v}
  		case 64:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
  			if m.RangeEnd == nil {
  				m.RangeEnd = []byte{}
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *TxnRequest) 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 ErrIntOverflowRpc
  			}
  			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: TxnRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: TxnRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Compare", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Compare = append(m.Compare, &Compare{})
  			if err := m.Compare[len(m.Compare)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Success = append(m.Success, &RequestOp{})
  			if err := m.Success[len(m.Success)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Failure = append(m.Failure, &RequestOp{})
  			if err := m.Failure[len(m.Failure)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *TxnResponse) 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 ErrIntOverflowRpc
  			}
  			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: TxnResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: TxnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Succeeded = bool(v != 0)
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Responses = append(m.Responses, &ResponseOp{})
  			if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *CompactionRequest) 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 ErrIntOverflowRpc
  			}
  			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: CompactionRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: CompactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
  			}
  			m.Revision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Revision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Physical = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *CompactionResponse) 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 ErrIntOverflowRpc
  			}
  			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: CompactionResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: CompactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *HashRequest) 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 ErrIntOverflowRpc
  			}
  			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: HashRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: HashRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *HashKVRequest) 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 ErrIntOverflowRpc
  			}
  			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: HashKVRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: HashKVRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
  			}
  			m.Revision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Revision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *HashKVResponse) 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 ErrIntOverflowRpc
  			}
  			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: HashKVResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: HashKVResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
  			}
  			m.Hash = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Hash |= uint32(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CompactRevision", wireType)
  			}
  			m.CompactRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.CompactRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field HashRevision", wireType)
  			}
  			m.HashRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.HashRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *HashResponse) 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 ErrIntOverflowRpc
  			}
  			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: HashResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: HashResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
  			}
  			m.Hash = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Hash |= uint32(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *SnapshotRequest) 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 ErrIntOverflowRpc
  			}
  			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: SnapshotRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: SnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *SnapshotResponse) 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 ErrIntOverflowRpc
  			}
  			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: SnapshotResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: SnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RemainingBytes", wireType)
  			}
  			m.RemainingBytes = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.RemainingBytes |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Blob", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Blob = append(m.Blob[:0], dAtA[iNdEx:postIndex]...)
  			if m.Blob == nil {
  				m.Blob = []byte{}
  			}
  			iNdEx = postIndex
  		case 4:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Version = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *WatchRequest) 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 ErrIntOverflowRpc
  			}
  			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: WatchRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: WatchRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CreateRequest", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &WatchCreateRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.RequestUnion = &WatchRequest_CreateRequest{v}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CancelRequest", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &WatchCancelRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.RequestUnion = &WatchRequest_CancelRequest{v}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ProgressRequest", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			v := &WatchProgressRequest{}
  			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			m.RequestUnion = &WatchRequest_ProgressRequest{v}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *WatchCreateRequest) 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 ErrIntOverflowRpc
  			}
  			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: WatchCreateRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: WatchCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  			if m.Key == nil {
  				m.Key = []byte{}
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
  			if m.RangeEnd == nil {
  				m.RangeEnd = []byte{}
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field StartRevision", wireType)
  			}
  			m.StartRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.StartRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ProgressNotify", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.ProgressNotify = bool(v != 0)
  		case 5:
  			if wireType == 0 {
  				var v WatchCreateRequest_FilterType
  				for shift := uint(0); ; shift += 7 {
  					if shift >= 64 {
  						return ErrIntOverflowRpc
  					}
  					if iNdEx >= l {
  						return io.ErrUnexpectedEOF
  					}
  					b := dAtA[iNdEx]
  					iNdEx++
  					v |= WatchCreateRequest_FilterType(b&0x7F) << shift
  					if b < 0x80 {
  						break
  					}
  				}
  				m.Filters = append(m.Filters, v)
  			} else if wireType == 2 {
  				var packedLen int
  				for shift := uint(0); ; shift += 7 {
  					if shift >= 64 {
  						return ErrIntOverflowRpc
  					}
  					if iNdEx >= l {
  						return io.ErrUnexpectedEOF
  					}
  					b := dAtA[iNdEx]
  					iNdEx++
  					packedLen |= int(b&0x7F) << shift
  					if b < 0x80 {
  						break
  					}
  				}
  				if packedLen < 0 {
  					return ErrInvalidLengthRpc
  				}
  				postIndex := iNdEx + packedLen
  				if postIndex < 0 {
  					return ErrInvalidLengthRpc
  				}
  				if postIndex > l {
  					return io.ErrUnexpectedEOF
  				}
  				var elementCount int
  				if elementCount != 0 && len(m.Filters) == 0 {
  					m.Filters = make([]WatchCreateRequest_FilterType, 0, elementCount)
  				}
  				for iNdEx < postIndex {
  					var v WatchCreateRequest_FilterType
  					for shift := uint(0); ; shift += 7 {
  						if shift >= 64 {
  							return ErrIntOverflowRpc
  						}
  						if iNdEx >= l {
  							return io.ErrUnexpectedEOF
  						}
  						b := dAtA[iNdEx]
  						iNdEx++
  						v |= WatchCreateRequest_FilterType(b&0x7F) << shift
  						if b < 0x80 {
  							break
  						}
  					}
  					m.Filters = append(m.Filters, v)
  				}
  			} else {
  				return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
  			}
  		case 6:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.PrevKv = bool(v != 0)
  		case 7:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType)
  			}
  			m.WatchId = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.WatchId |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 8:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Fragment", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Fragment = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *WatchCancelRequest) 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 ErrIntOverflowRpc
  			}
  			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: WatchCancelRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: WatchCancelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType)
  			}
  			m.WatchId = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.WatchId |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *WatchProgressRequest) 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 ErrIntOverflowRpc
  			}
  			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: WatchProgressRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: WatchProgressRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *WatchResponse) 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 ErrIntOverflowRpc
  			}
  			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: WatchResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: WatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType)
  			}
  			m.WatchId = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.WatchId |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Created = bool(v != 0)
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Canceled", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Canceled = bool(v != 0)
  		case 5:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CompactRevision", wireType)
  			}
  			m.CompactRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.CompactRevision |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 6:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field CancelReason", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.CancelReason = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 7:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Fragment", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Fragment = bool(v != 0)
  		case 11:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Events = append(m.Events, &mvccpb.Event{})
  			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseGrantRequest) 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 ErrIntOverflowRpc
  			}
  			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: LeaseGrantRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseGrantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
  			}
  			m.TTL = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.TTL |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseGrantResponse) 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 ErrIntOverflowRpc
  			}
  			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: LeaseGrantResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseGrantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
  			}
  			m.TTL = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.TTL |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Error = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseRevokeRequest) 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 ErrIntOverflowRpc
  			}
  			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: LeaseRevokeRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseRevokeRequest: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseRevokeResponse) 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 ErrIntOverflowRpc
  			}
  			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: LeaseRevokeResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseRevokeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseCheckpoint) 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 ErrIntOverflowRpc
  			}
  			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: LeaseCheckpoint: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseCheckpoint: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Remaining_TTL", wireType)
  			}
  			m.Remaining_TTL = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Remaining_TTL |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseCheckpointRequest) 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 ErrIntOverflowRpc
  			}
  			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: LeaseCheckpointRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseCheckpointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Checkpoints", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Checkpoints = append(m.Checkpoints, &LeaseCheckpoint{})
  			if err := m.Checkpoints[len(m.Checkpoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseCheckpointResponse) 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 ErrIntOverflowRpc
  			}
  			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: LeaseCheckpointResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseCheckpointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseKeepAliveRequest) 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 ErrIntOverflowRpc
  			}
  			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: LeaseKeepAliveRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseKeepAliveRequest: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseKeepAliveResponse) 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 ErrIntOverflowRpc
  			}
  			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: LeaseKeepAliveResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseKeepAliveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
  			}
  			m.TTL = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.TTL |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseTimeToLiveRequest) 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 ErrIntOverflowRpc
  			}
  			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: LeaseTimeToLiveRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseTimeToLiveRequest: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Keys = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseTimeToLiveResponse) 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 ErrIntOverflowRpc
  			}
  			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: LeaseTimeToLiveResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseTimeToLiveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
  			}
  			m.TTL = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.TTL |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field GrantedTTL", wireType)
  			}
  			m.GrantedTTL = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.GrantedTTL |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 5:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
  			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseLeasesRequest) 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 ErrIntOverflowRpc
  			}
  			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: LeaseLeasesRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseLeasesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseStatus) 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 ErrIntOverflowRpc
  			}
  			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: LeaseStatus: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseStatus: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *LeaseLeasesResponse) 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 ErrIntOverflowRpc
  			}
  			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: LeaseLeasesResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: LeaseLeasesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Leases", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Leases = append(m.Leases, &LeaseStatus{})
  			if err := m.Leases[len(m.Leases)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *Member) 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 ErrIntOverflowRpc
  			}
  			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: Member: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: Member: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 PeerURLs", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		case 4:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field ClientURLs", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.ClientURLs = append(m.ClientURLs, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		case 5:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field IsLearner", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.IsLearner = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberAddRequest) 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 ErrIntOverflowRpc
  			}
  			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: MemberAddRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberAddRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field IsLearner", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.IsLearner = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberAddResponse) 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 ErrIntOverflowRpc
  			}
  			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: MemberAddResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberAddResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Member == nil {
  				m.Member = &Member{}
  			}
  			if err := m.Member.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Members = append(m.Members, &Member{})
  			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberRemoveRequest) 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 ErrIntOverflowRpc
  			}
  			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: MemberRemoveRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberRemoveRequest: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberRemoveResponse) 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 ErrIntOverflowRpc
  			}
  			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: MemberRemoveResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberRemoveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Members = append(m.Members, &Member{})
  			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberUpdateRequest) 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 ErrIntOverflowRpc
  			}
  			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: MemberUpdateRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberUpdateRequest: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberUpdateResponse) 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 ErrIntOverflowRpc
  			}
  			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: MemberUpdateResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Members = append(m.Members, &Member{})
  			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberListRequest) 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 ErrIntOverflowRpc
  			}
  			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: MemberListRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Linearizable", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Linearizable = bool(v != 0)
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberListResponse) 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 ErrIntOverflowRpc
  			}
  			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: MemberListResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Members = append(m.Members, &Member{})
  			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberPromoteRequest) 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 ErrIntOverflowRpc
  			}
  			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: MemberPromoteRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberPromoteRequest: 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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.ID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MemberPromoteResponse) 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 ErrIntOverflowRpc
  			}
  			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: MemberPromoteResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MemberPromoteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Members = append(m.Members, &Member{})
  			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DefragmentRequest) 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 ErrIntOverflowRpc
  			}
  			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: DefragmentRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DefragmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DefragmentResponse) 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 ErrIntOverflowRpc
  			}
  			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: DefragmentResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DefragmentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MoveLeaderRequest) 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 ErrIntOverflowRpc
  			}
  			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: MoveLeaderRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MoveLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field TargetID", wireType)
  			}
  			m.TargetID = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.TargetID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *MoveLeaderResponse) 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 ErrIntOverflowRpc
  			}
  			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: MoveLeaderResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: MoveLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AlarmRequest) 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 ErrIntOverflowRpc
  			}
  			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: AlarmRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AlarmRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Action |= AlarmRequest_AlarmAction(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
  			}
  			m.MemberID = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MemberID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType)
  			}
  			m.Alarm = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Alarm |= AlarmType(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AlarmMember) 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 ErrIntOverflowRpc
  			}
  			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: AlarmMember: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AlarmMember: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
  			}
  			m.MemberID = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.MemberID |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType)
  			}
  			m.Alarm = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Alarm |= AlarmType(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AlarmResponse) 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 ErrIntOverflowRpc
  			}
  			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: AlarmResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AlarmResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Alarms", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Alarms = append(m.Alarms, &AlarmMember{})
  			if err := m.Alarms[len(m.Alarms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DowngradeRequest) 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 ErrIntOverflowRpc
  			}
  			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: DowngradeRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DowngradeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Action |= DowngradeRequest_DowngradeAction(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Version = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DowngradeResponse) 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 ErrIntOverflowRpc
  			}
  			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: DowngradeResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DowngradeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Version = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DowngradeVersionTestRequest) 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 ErrIntOverflowRpc
  			}
  			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: DowngradeVersionTestRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DowngradeVersionTestRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Ver", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Ver = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *StatusRequest) 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 ErrIntOverflowRpc
  			}
  			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: StatusRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *StatusResponse) 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 ErrIntOverflowRpc
  			}
  			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: StatusResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Version = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field DbSize", wireType)
  			}
  			m.DbSize = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.DbSize |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 4:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
  			}
  			m.Leader = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.Leader |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 5:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RaftIndex", wireType)
  			}
  			m.RaftIndex = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.RaftIndex |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 6:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType)
  			}
  			m.RaftTerm = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.RaftTerm |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 7:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RaftAppliedIndex", wireType)
  			}
  			m.RaftAppliedIndex = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.RaftAppliedIndex |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 8:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Errors", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Errors = append(m.Errors, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		case 9:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field DbSizeInUse", wireType)
  			}
  			m.DbSizeInUse = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.DbSizeInUse |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 10:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field IsLearner", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.IsLearner = bool(v != 0)
  		case 11:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field StorageVersion", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.StorageVersion = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 12:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field DbSizeQuota", wireType)
  			}
  			m.DbSizeQuota = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.DbSizeQuota |= int64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		case 13:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field DowngradeInfo", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.DowngradeInfo == nil {
  				m.DowngradeInfo = &DowngradeInfo{}
  			}
  			if err := m.DowngradeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *DowngradeInfo) 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 ErrIntOverflowRpc
  			}
  			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: DowngradeInfo: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: DowngradeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Enabled = bool(v != 0)
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field TargetVersion", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.TargetVersion = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthEnableRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthEnableRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthEnableRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthDisableRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthDisableRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthDisableRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthStatusRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthStatusRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthenticateRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthenticateRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthenticateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Password = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserAddRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserAddRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserAddRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Password = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Options == nil {
  				m.Options = &authpb.UserAddOptions{}
  			}
  			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 4:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field HashedPassword", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.HashedPassword = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserGetRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserGetRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserDeleteRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserDeleteRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserChangePasswordRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserChangePasswordRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserChangePasswordRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Password = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field HashedPassword", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.HashedPassword = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserGrantRoleRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserGrantRoleRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserGrantRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.User = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Role = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserRevokeRoleRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserRevokeRoleRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserRevokeRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Role = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleAddRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleAddRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleAddRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleGetRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleGetRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Role = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserListRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserListRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleListRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleListRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleDeleteRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleDeleteRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Role = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleGrantPermissionRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleGrantPermissionRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleGrantPermissionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			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 ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Name = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Perm", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Perm == nil {
  				m.Perm = &authpb.Permission{}
  			}
  			if err := m.Perm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleRevokePermissionRequest) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleRevokePermissionRequest: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleRevokePermissionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Role = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  			if m.Key == nil {
  				m.Key = []byte{}
  			}
  			iNdEx = postIndex
  		case 3:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
  			}
  			var byteLen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				byteLen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if byteLen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + byteLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
  			if m.RangeEnd == nil {
  				m.RangeEnd = []byte{}
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthEnableResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthEnableResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthEnableResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthDisableResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthDisableResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthDisableResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthStatusResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthStatusResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
  			}
  			var v int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				v |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			m.Enabled = bool(v != 0)
  		case 3:
  			if wireType != 0 {
  				return fmt.Errorf("proto: wrong wireType = %d for field AuthRevision", wireType)
  			}
  			m.AuthRevision = 0
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				m.AuthRevision |= uint64(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthenticateResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthenticateResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthenticateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Token = string(dAtA[iNdEx:postIndex])
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserAddResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserAddResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserAddResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserGetResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserGetResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserDeleteResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserDeleteResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserChangePasswordResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserChangePasswordResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserChangePasswordResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserGrantRoleResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserGrantRoleResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserGrantRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserRevokeRoleResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserRevokeRoleResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserRevokeRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleAddResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleAddResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleAddResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleGetResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleGetResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Perm", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Perm = append(m.Perm, &authpb.Permission{})
  			if err := m.Perm[len(m.Perm)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleListResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleListResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthUserListResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthUserListResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthUserListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		case 2:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType)
  			}
  			var stringLen uint64
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				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 ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + intStringLen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			m.Users = append(m.Users, string(dAtA[iNdEx:postIndex]))
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleDeleteResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleDeleteResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleGrantPermissionResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleGrantPermissionResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleGrantPermissionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 *AuthRoleRevokePermissionResponse) 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 ErrIntOverflowRpc
  			}
  			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: AuthRoleRevokePermissionResponse: wiretype end group for non-group")
  		}
  		if fieldNum <= 0 {
  			return fmt.Errorf("proto: AuthRoleRevokePermissionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
  		}
  		switch fieldNum {
  		case 1:
  			if wireType != 2 {
  				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
  			}
  			var msglen int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return io.ErrUnexpectedEOF
  				}
  				b := dAtA[iNdEx]
  				iNdEx++
  				msglen |= int(b&0x7F) << shift
  				if b < 0x80 {
  					break
  				}
  			}
  			if msglen < 0 {
  				return ErrInvalidLengthRpc
  			}
  			postIndex := iNdEx + msglen
  			if postIndex < 0 {
  				return ErrInvalidLengthRpc
  			}
  			if postIndex > l {
  				return io.ErrUnexpectedEOF
  			}
  			if m.Header == nil {
  				m.Header = &ResponseHeader{}
  			}
  			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  				return err
  			}
  			iNdEx = postIndex
  		default:
  			iNdEx = preIndex
  			skippy, err := skipRpc(dAtA[iNdEx:])
  			if err != nil {
  				return err
  			}
  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  				return ErrInvalidLengthRpc
  			}
  			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 skipRpc(dAtA []byte) (n int, err error) {
  	l := len(dAtA)
  	iNdEx := 0
  	depth := 0
  	for iNdEx < l {
  		var wire uint64
  		for shift := uint(0); ; shift += 7 {
  			if shift >= 64 {
  				return 0, ErrIntOverflowRpc
  			}
  			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, ErrIntOverflowRpc
  				}
  				if iNdEx >= l {
  					return 0, io.ErrUnexpectedEOF
  				}
  				iNdEx++
  				if dAtA[iNdEx-1] < 0x80 {
  					break
  				}
  			}
  		case 1:
  			iNdEx += 8
  		case 2:
  			var length int
  			for shift := uint(0); ; shift += 7 {
  				if shift >= 64 {
  					return 0, ErrIntOverflowRpc
  				}
  				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, ErrInvalidLengthRpc
  			}
  			iNdEx += length
  		case 3:
  			depth++
  		case 4:
  			if depth == 0 {
  				return 0, ErrUnexpectedEndOfGroupRpc
  			}
  			depth--
  		case 5:
  			iNdEx += 4
  		default:
  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  		}
  		if iNdEx < 0 {
  			return 0, ErrInvalidLengthRpc
  		}
  		if depth == 0 {
  			return iNdEx, nil
  		}
  	}
  	return 0, io.ErrUnexpectedEOF
  }
  
  var (
  	ErrInvalidLengthRpc        = fmt.Errorf("proto: negative length found during unmarshaling")
  	ErrIntOverflowRpc          = fmt.Errorf("proto: integer overflow")
  	ErrUnexpectedEndOfGroupRpc = fmt.Errorf("proto: unexpected end of group")
  )
  