From dadf9dd520ed585b946f08dd34fce0537f6253b6 Mon Sep 17 00:00:00 2001 From: XuWentao Date: Tue, 13 Mar 2018 16:19:32 +0800 Subject: [PATCH] add user kv api --- Gopkg.lock | 6 +- Gopkg.toml | 4 + pd-client/client.go | 79 + server/core/kv.go | 16 + server/grpc_service.go | 53 + .../pingcap/kvproto/pkg/pdpb/pdpb.pb.go | 1793 +++++++++++++++-- 6 files changed, 1733 insertions(+), 218 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index e69d59c08b7..7db01e93248 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -248,14 +248,14 @@ revision = "1c287c953996ab3a0bf535dba9d53d809d3dc0b6" [[projects]] - branch = "master" - name = "github.com/pingcap/kvproto" + branch = "do_gc_distributedly" + name = "github.com/wentaoxu/kvproto" packages = [ "pkg/eraftpb", "pkg/metapb", "pkg/pdpb" ] - revision = "7fe0eb69e3e6d5e03c2222651b065ecfe3e1ae31" + revision = "f8f9cd36a80ac771d00b6b682d93cef834f4e473" [[projects]] name = "github.com/prometheus/client_golang" diff --git a/Gopkg.toml b/Gopkg.toml index 3a815c39446..b5dcc76bb78 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -35,3 +35,7 @@ [[constraint]] name = "github.com/chzyer/readline" branch = "master" + +[[constraint]] + name = "github.com/wentaoxu/kvproto" + branch = "do_gc_distributedly" diff --git a/pd-client/client.go b/pd-client/client.go index e52b606a255..d6a542e3f4d 100644 --- a/pd-client/client.go +++ b/pd-client/client.go @@ -53,6 +53,12 @@ type Client interface { // The store may expire later. Caller is responsible for caching and taking care // of store change. GetStore(ctx context.Context, storeID uint64) (*metapb.Store, error) + // GetUserKV get the user kv from pd. + GetUserKV(ctx context.Context, key string) (string, error) + // PutUserKV put the user kv to pd. + PutUserKV(ctx context.Context, key string, value string) error + // DeleteUserKV delete the user kv from pd. + DeleteUserKV(ctx context.Context, key string) error // Close closes the client. Close() } @@ -622,6 +628,79 @@ func (c *client) GetStore(ctx context.Context, storeID uint64) (*metapb.Store, e return store, nil } +func (c *client) GetUserKV(ctx context.Context, key string) (string, error) { + if span := opentracing.SpanFromContext(ctx); span != nil { + span = opentracing.StartSpan("pdclient.GetUserKV", opentracing.ChildOf(span.Context())) + defer span.Finish() + } + start := time.Now() + defer func() { cmdDuration.WithLabelValues("get_user_key").Observe(time.Since(start).Seconds()) }() + + ctx, cancel := context.WithTimeout(ctx, pdTimeout) + resp, err := c.leaderClient().GetUserKV(ctx, &pdpb.GetUserKVRequest{ + Header: c.requestHeader(), + Key: key, + }) + requestDuration.WithLabelValues("get_user_key").Observe(time.Since(start).Seconds()) + cancel() + + if err != nil { + cmdFailedDuration.WithLabelValues("get_user_key").Observe(time.Since(start).Seconds()) + c.scheduleCheckLeader() + return "", errors.Trace(err) + } + return resp.GetValue(), nil +} + +func (c *client) PutUserKV(ctx context.Context, key string, value string) error { + if span := opentracing.SpanFromContext(ctx); span != nil { + span = opentracing.StartSpan("pdclient.PutUserKV", opentracing.ChildOf(span.Context())) + defer span.Finish() + } + start := time.Now() + defer func() { cmdDuration.WithLabelValues("put_user_key").Observe(time.Since(start).Seconds()) }() + + ctx, cancel := context.WithTimeout(ctx, pdTimeout) + _, err := c.leaderClient().PutUserKV(ctx, &pdpb.PutUserKVRequest{ + Header: c.requestHeader(), + Key: key, + Value: value, + }) + requestDuration.WithLabelValues("put_user_key").Observe(time.Since(start).Seconds()) + cancel() + + if err != nil { + cmdFailedDuration.WithLabelValues("put_user_key").Observe(time.Since(start).Seconds()) + c.scheduleCheckLeader() + return errors.Trace(err) + } + return nil +} + +func (c *client) DeleteUserKV(ctx context.Context, key string) error { + if span := opentracing.SpanFromContext(ctx); span != nil { + span = opentracing.StartSpan("pdclient.DeleteUserKV", opentracing.ChildOf(span.Context())) + defer span.Finish() + } + start := time.Now() + defer func() { cmdDuration.WithLabelValues("delete_user_kv").Observe(time.Since(start).Seconds()) }() + + ctx, cancel := context.WithTimeout(ctx, pdTimeout) + _, err := c.leaderClient().DeleteUserKV(ctx, &pdpb.DeleteUserKVRequest{ + Header: c.requestHeader(), + Key: key, + }) + requestDuration.WithLabelValues("delete_user_kv").Observe(time.Since(start).Seconds()) + cancel() + + if err != nil { + cmdFailedDuration.WithLabelValues("delete_user_kv").Observe(time.Since(start).Seconds()) + c.scheduleCheckLeader() + return errors.Trace(err) + } + return nil +} + func (c *client) requestHeader() *pdpb.RequestHeader { return &pdpb.RequestHeader{ ClusterId: c.clusterID, diff --git a/server/core/kv.go b/server/core/kv.go index 650b3d3c7d9..5ba9ef28435 100644 --- a/server/core/kv.go +++ b/server/core/kv.go @@ -29,6 +29,7 @@ const ( clusterPath = "raft" configPath = "config" schedulePath = "schedule" + userPath = "user" ) // KV wraps all kv operations, keep it stateless. @@ -239,3 +240,18 @@ func (kv *KV) saveProto(key string, msg proto.Message) error { } return kv.Save(key, string(value)) } + +// GetUserKV get key from pd under dir 'user'. +func (kv *KV) GetUserKV(key string) (string, error) { + return kv.Load(path.Join(userPath, key)) +} + +// PutUserKV put key to pd under dir 'user'. +func (kv *KV) PutUserKV(key string, value string) error { + return kv.Save(path.Join(userPath, key), value) +} + +// DeleteUserKV delete key from pd under dir 'user'. +func (kv *KV) DeleteUserKV(key string) error { + return kv.Delete(path.Join(userPath, key)) +} diff --git a/server/grpc_service.go b/server/grpc_service.go index 98b1c9f9788..09d1fedb385 100644 --- a/server/grpc_service.go +++ b/server/grpc_service.go @@ -555,3 +555,56 @@ func (s *Server) notBootstrappedHeader() *pdpb.ResponseHeader { Message: "cluster is not bootstrapped", }) } + +// GetUserKV get key from pd under dir 'user'. +func (s *Server) GetUserKV(ctx context.Context, request *pdpb.GetUserKVRequest) (*pdpb.GetUserKVResponse, error) { + if err := s.validateRequest(request.GetHeader()); err != nil { + return nil, errors.Trace(err) + } + + value, err := s.kv.GetUserKV(request.GetKey()) + if err != nil { + return nil, errors.Trace(err) + } + + return &pdpb.GetUserKVResponse{ + Header: s.header(), + Key: request.GetKey(), + Value: value, + }, nil +} + +// PutUserKV put key to pd under dir 'user'. +func (s *Server) PutUserKV(ctx context.Context, request *pdpb.PutUserKVRequest) (*pdpb.PutUserKVResponse, error) { + if err := s.validateRequest(request.GetHeader()); err != nil { + return nil, errors.Trace(err) + } + + err := s.kv.PutUserKV(request.GetKey(), request.GetValue()) + if err != nil { + return nil, errors.Trace(err) + } + + return &pdpb.PutUserKVResponse{ + Header: s.header(), + Key: request.GetKey(), + Value: request.GetValue(), + }, nil +} + +// DeleteUserKV delete key from pd under dir 'user'. +func (s *Server) DeleteUserKV(ctx context.Context, request *pdpb.DeleteUserKVRequest) (*pdpb.DeleteUserKVResponse, error) { + if err := s.validateRequest(request.GetHeader()); err != nil { + return nil, errors.Trace(err) + } + + err := s.kv.DeleteUserKV(request.GetKey()) + if err != nil { + return nil, errors.Trace(err) + } + + return &pdpb.DeleteUserKVResponse{ + Header: s.header(), + Key: request.GetKey(), + }, nil +} diff --git a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go index 6d8dc0e72d8..79da6e393fa 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go @@ -51,6 +51,12 @@ StoreHeartbeatResponse ScatterRegionRequest ScatterRegionResponse + GetUserKVRequest + GetUserKVResponse + PutUserKVRequest + PutUserKVResponse + DeleteUserKVRequest + DeleteUserKVResponse */ package pdpb @@ -1359,6 +1365,174 @@ func (m *ScatterRegionResponse) GetHeader() *ResponseHeader { return nil } +type GetUserKVRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *GetUserKVRequest) Reset() { *m = GetUserKVRequest{} } +func (m *GetUserKVRequest) String() string { return proto.CompactTextString(m) } +func (*GetUserKVRequest) ProtoMessage() {} +func (*GetUserKVRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{42} } + +func (m *GetUserKVRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *GetUserKVRequest) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +type GetUserKVResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *GetUserKVResponse) Reset() { *m = GetUserKVResponse{} } +func (m *GetUserKVResponse) String() string { return proto.CompactTextString(m) } +func (*GetUserKVResponse) ProtoMessage() {} +func (*GetUserKVResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{43} } + +func (m *GetUserKVResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *GetUserKVResponse) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *GetUserKVResponse) GetValue() string { + if m != nil { + return m.Value + } + return "" +} + +type PutUserKVRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *PutUserKVRequest) Reset() { *m = PutUserKVRequest{} } +func (m *PutUserKVRequest) String() string { return proto.CompactTextString(m) } +func (*PutUserKVRequest) ProtoMessage() {} +func (*PutUserKVRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{44} } + +func (m *PutUserKVRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *PutUserKVRequest) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *PutUserKVRequest) GetValue() string { + if m != nil { + return m.Value + } + return "" +} + +type PutUserKVResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *PutUserKVResponse) Reset() { *m = PutUserKVResponse{} } +func (m *PutUserKVResponse) String() string { return proto.CompactTextString(m) } +func (*PutUserKVResponse) ProtoMessage() {} +func (*PutUserKVResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{45} } + +func (m *PutUserKVResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *PutUserKVResponse) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *PutUserKVResponse) GetValue() string { + if m != nil { + return m.Value + } + return "" +} + +type DeleteUserKVRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *DeleteUserKVRequest) Reset() { *m = DeleteUserKVRequest{} } +func (m *DeleteUserKVRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteUserKVRequest) ProtoMessage() {} +func (*DeleteUserKVRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{46} } + +func (m *DeleteUserKVRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *DeleteUserKVRequest) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +type DeleteUserKVResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *DeleteUserKVResponse) Reset() { *m = DeleteUserKVResponse{} } +func (m *DeleteUserKVResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteUserKVResponse) ProtoMessage() {} +func (*DeleteUserKVResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{47} } + +func (m *DeleteUserKVResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *DeleteUserKVResponse) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + func init() { proto.RegisterType((*RequestHeader)(nil), "pdpb.RequestHeader") proto.RegisterType((*ResponseHeader)(nil), "pdpb.ResponseHeader") @@ -1402,6 +1576,12 @@ func init() { proto.RegisterType((*StoreHeartbeatResponse)(nil), "pdpb.StoreHeartbeatResponse") proto.RegisterType((*ScatterRegionRequest)(nil), "pdpb.ScatterRegionRequest") proto.RegisterType((*ScatterRegionResponse)(nil), "pdpb.ScatterRegionResponse") + proto.RegisterType((*GetUserKVRequest)(nil), "pdpb.GetUserKVRequest") + proto.RegisterType((*GetUserKVResponse)(nil), "pdpb.GetUserKVResponse") + proto.RegisterType((*PutUserKVRequest)(nil), "pdpb.PutUserKVRequest") + proto.RegisterType((*PutUserKVResponse)(nil), "pdpb.PutUserKVResponse") + proto.RegisterType((*DeleteUserKVRequest)(nil), "pdpb.DeleteUserKVRequest") + proto.RegisterType((*DeleteUserKVResponse)(nil), "pdpb.DeleteUserKVResponse") proto.RegisterEnum("pdpb.ErrorType", ErrorType_name, ErrorType_value) } @@ -1435,6 +1615,9 @@ type PDClient interface { GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) + GetUserKV(ctx context.Context, in *GetUserKVRequest, opts ...grpc.CallOption) (*GetUserKVResponse, error) + PutUserKV(ctx context.Context, in *PutUserKVRequest, opts ...grpc.CallOption) (*PutUserKVResponse, error) + DeleteUserKV(ctx context.Context, in *DeleteUserKVRequest, opts ...grpc.CallOption) (*DeleteUserKVResponse, error) } type pDClient struct { @@ -1642,6 +1825,33 @@ func (c *pDClient) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, return out, nil } +func (c *pDClient) GetUserKV(ctx context.Context, in *GetUserKVRequest, opts ...grpc.CallOption) (*GetUserKVResponse, error) { + out := new(GetUserKVResponse) + err := grpc.Invoke(ctx, "/pdpb.PD/GetUserKV", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *pDClient) PutUserKV(ctx context.Context, in *PutUserKVRequest, opts ...grpc.CallOption) (*PutUserKVResponse, error) { + out := new(PutUserKVResponse) + err := grpc.Invoke(ctx, "/pdpb.PD/PutUserKV", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *pDClient) DeleteUserKV(ctx context.Context, in *DeleteUserKVRequest, opts ...grpc.CallOption) (*DeleteUserKVResponse, error) { + out := new(DeleteUserKVResponse) + err := grpc.Invoke(ctx, "/pdpb.PD/DeleteUserKV", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // Server API for PD service type PDServer interface { @@ -1664,6 +1874,9 @@ type PDServer interface { GetClusterConfig(context.Context, *GetClusterConfigRequest) (*GetClusterConfigResponse, error) PutClusterConfig(context.Context, *PutClusterConfigRequest) (*PutClusterConfigResponse, error) ScatterRegion(context.Context, *ScatterRegionRequest) (*ScatterRegionResponse, error) + GetUserKV(context.Context, *GetUserKVRequest) (*GetUserKVResponse, error) + PutUserKV(context.Context, *PutUserKVRequest) (*PutUserKVResponse, error) + DeleteUserKV(context.Context, *DeleteUserKVRequest) (*DeleteUserKVResponse, error) } func RegisterPDServer(s *grpc.Server, srv PDServer) { @@ -1992,6 +2205,60 @@ func _PD_ScatterRegion_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _PD_GetUserKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetUserKVRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).GetUserKV(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetUserKV", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetUserKV(ctx, req.(*GetUserKVRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _PD_PutUserKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutUserKVRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).PutUserKV(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/PutUserKV", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).PutUserKV(ctx, req.(*PutUserKVRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _PD_DeleteUserKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteUserKVRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).DeleteUserKV(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/DeleteUserKV", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).DeleteUserKV(ctx, req.(*DeleteUserKVRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _PD_serviceDesc = grpc.ServiceDesc{ ServiceName: "pdpb.PD", HandlerType: (*PDServer)(nil), @@ -2056,6 +2323,18 @@ var _PD_serviceDesc = grpc.ServiceDesc{ MethodName: "ScatterRegion", Handler: _PD_ScatterRegion_Handler, }, + { + MethodName: "GetUserKV", + Handler: _PD_GetUserKV_Handler, + }, + { + MethodName: "PutUserKV", + Handler: _PD_PutUserKV_Handler, + }, + { + MethodName: "DeleteUserKV", + Handler: _PD_DeleteUserKV_Handler, + }, }, Streams: []grpc.StreamDesc{ { @@ -3743,77 +4022,299 @@ func (m *ScatterRegionResponse) MarshalTo(dAtA []byte) (int, error) { return i, nil } -func encodeFixed64Pdpb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Pdpb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} -func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int { - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return offset + 1 -} -func (m *RequestHeader) Size() (n int) { - var l int - _ = l - if m.ClusterId != 0 { - n += 1 + sovPdpb(uint64(m.ClusterId)) +func (m *GetUserKVRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *ResponseHeader) Size() (n int) { +func (m *GetUserKVRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i var l int _ = l - if m.ClusterId != 0 { - n += 1 + sovPdpb(uint64(m.ClusterId)) + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n63, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n63 } - if m.Error != nil { - l = m.Error.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.Key) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) } - return n + return i, nil } -func (m *Error) Size() (n int) { - var l int - _ = l - if m.Type != 0 { - n += 1 + sovPdpb(uint64(m.Type)) - } - l = len(m.Message) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) +func (m *GetUserKVResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *TsoRequest) Size() (n int) { +func (m *GetUserKVResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i var l int _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Count != 0 { - n += 1 + sovPdpb(uint64(m.Count)) + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n64, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n64 + } + if len(m.Key) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + if len(m.Value) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Value))) + i += copy(dAtA[i:], m.Value) + } + return i, nil +} + +func (m *PutUserKVRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PutUserKVRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n65, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n65 + } + if len(m.Key) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + if len(m.Value) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Value))) + i += copy(dAtA[i:], m.Value) + } + return i, nil +} + +func (m *PutUserKVResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PutUserKVResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n66, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n66 + } + if len(m.Key) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + if len(m.Value) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Value))) + i += copy(dAtA[i:], m.Value) + } + return i, nil +} + +func (m *DeleteUserKVRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeleteUserKVRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n67, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n67 + } + if len(m.Key) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + return i, nil +} + +func (m *DeleteUserKVResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DeleteUserKVResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n68, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n68 + } + if len(m.Key) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + i += copy(dAtA[i:], m.Key) + } + return i, nil +} + +func encodeFixed64Pdpb(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Pdpb(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *RequestHeader) Size() (n int) { + var l int + _ = l + if m.ClusterId != 0 { + n += 1 + sovPdpb(uint64(m.ClusterId)) + } + return n +} + +func (m *ResponseHeader) Size() (n int) { + var l int + _ = l + if m.ClusterId != 0 { + n += 1 + sovPdpb(uint64(m.ClusterId)) + } + if m.Error != nil { + l = m.Error.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + return n +} + +func (m *Error) Size() (n int) { + var l int + _ = l + if m.Type != 0 { + n += 1 + sovPdpb(uint64(m.Type)) + } + l = len(m.Message) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + return n +} + +func (m *TsoRequest) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Count != 0 { + n += 1 + sovPdpb(uint64(m.Count)) } return n } @@ -4431,49 +4932,145 @@ func (m *ScatterRegionResponse) Size() (n int) { return n } -func sovPdpb(x uint64) (n int) { - for { - n++ - x >>= 7 - if x == 0 { - break - } +func (m *GetUserKVRequest) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) } return n } -func sozPdpb(x uint64) (n int) { - return sovPdpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + +func (m *GetUserKVResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + return n } -func (m *RequestHeader) 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 ErrIntOverflowPdpb - } - 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: RequestHeader: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + +func (m *PutUserKVRequest) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + return n +} + +func (m *PutUserKVResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + return n +} + +func (m *DeleteUserKVRequest) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + return n +} + +func (m *DeleteUserKVResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + return n +} + +func sovPdpb(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozPdpb(x uint64) (n int) { + return sovPdpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *RequestHeader) 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 ErrIntOverflowPdpb + } + 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: RequestHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestHeader: 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) } @@ -9581,6 +10178,765 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *GetUserKVRequest) 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 ErrIntOverflowPdpb + } + 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: GetUserKVRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetUserKVRequest: 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 ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + 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 Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetUserKVResponse) 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 ErrIntOverflowPdpb + } + 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: GetUserKVResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetUserKVResponse: 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 ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + 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 Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PutUserKVRequest) 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 ErrIntOverflowPdpb + } + 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: PutUserKVRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PutUserKVRequest: 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 ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + 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 Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PutUserKVResponse) 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 ErrIntOverflowPdpb + } + 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: PutUserKVResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PutUserKVResponse: 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 ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + 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 Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeleteUserKVRequest) 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 ErrIntOverflowPdpb + } + 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: DeleteUserKVRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeleteUserKVRequest: 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 ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + 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 Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeleteUserKVResponse) 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 ErrIntOverflowPdpb + } + 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: DeleteUserKVResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeleteUserKVResponse: 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 ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + 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 Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + 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 ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipPdpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 @@ -9689,124 +11045,131 @@ var ( func init() { proto.RegisterFile("pdpb.proto", fileDescriptorPdpb) } var fileDescriptorPdpb = []byte{ - // 1889 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x19, 0xcb, 0x72, 0x23, 0x49, - 0xd1, 0x2d, 0x4b, 0xb2, 0x94, 0x7a, 0x4e, 0xf9, 0xa5, 0xd1, 0x8c, 0x8d, 0xb7, 0x66, 0x01, 0xef, - 0xb2, 0x2b, 0x66, 0x4d, 0x04, 0xb1, 0x11, 0x1b, 0x4b, 0xac, 0xfc, 0x98, 0x19, 0x33, 0x3b, 0x96, - 0xa3, 0xa4, 0x8d, 0x8d, 0xbd, 0x20, 0xda, 0x52, 0x59, 0x6e, 0xdc, 0xea, 0xee, 0xed, 0x2a, 0x8d, - 0xd1, 0x9c, 0x38, 0x71, 0x81, 0x08, 0xae, 0x1c, 0xb9, 0x13, 0xc1, 0x1f, 0x10, 0x1c, 0xb8, 0x70, - 0xe4, 0x13, 0x88, 0xe1, 0xcc, 0x3f, 0x10, 0xf5, 0xe8, 0xa7, 0x64, 0x63, 0x7a, 0xe0, 0xa4, 0xae, - 0xcc, 0xac, 0xac, 0xcc, 0xac, 0xcc, 0xac, 0xcc, 0x14, 0x80, 0x37, 0xf6, 0x2e, 0x3a, 0x9e, 0xef, - 0x72, 0x17, 0xe5, 0xc5, 0x77, 0xbb, 0x3a, 0xa5, 0xdc, 0x0c, 0x60, 0xed, 0x1a, 0xf5, 0xcd, 0x4b, - 0x1e, 0x2e, 0x37, 0x26, 0xee, 0xc4, 0x95, 0x9f, 0x3f, 0x14, 0x5f, 0x0a, 0x8a, 0x3b, 0x50, 0x23, - 0xf4, 0xdb, 0x19, 0x65, 0xfc, 0x05, 0x35, 0xc7, 0xd4, 0x47, 0x3b, 0x00, 0x23, 0x7b, 0xc6, 0x38, - 0xf5, 0x87, 0xd6, 0xb8, 0x65, 0xec, 0x19, 0xfb, 0x79, 0x52, 0xd6, 0x90, 0xd3, 0x31, 0x26, 0x50, - 0x27, 0x94, 0x79, 0xae, 0xc3, 0xe8, 0xbd, 0x36, 0xa0, 0xf7, 0xa0, 0x40, 0x7d, 0xdf, 0xf5, 0x5b, - 0xb9, 0x3d, 0x63, 0xbf, 0x72, 0x50, 0xe9, 0x48, 0xa9, 0x4f, 0x04, 0x88, 0x28, 0x0c, 0x7e, 0x06, - 0x05, 0xb9, 0x46, 0x4f, 0x20, 0xcf, 0xe7, 0x1e, 0x95, 0x4c, 0xea, 0x07, 0x8d, 0x18, 0xe9, 0x60, - 0xee, 0x51, 0x22, 0x91, 0xa8, 0x05, 0x6b, 0x53, 0xca, 0x98, 0x39, 0xa1, 0x92, 0x65, 0x99, 0x04, - 0x4b, 0xdc, 0x03, 0x18, 0x30, 0x57, 0xab, 0x83, 0x7e, 0x00, 0xc5, 0x2b, 0x29, 0xa1, 0x64, 0x57, - 0x39, 0x58, 0x57, 0xec, 0x12, 0xda, 0x12, 0x4d, 0x82, 0x36, 0xa0, 0x30, 0x72, 0x67, 0x0e, 0x97, - 0x2c, 0x6b, 0x44, 0x2d, 0x70, 0x17, 0xca, 0x03, 0x6b, 0x4a, 0x19, 0x37, 0xa7, 0x1e, 0x6a, 0x43, - 0xc9, 0xbb, 0x9a, 0x33, 0x6b, 0x64, 0xda, 0x92, 0xe3, 0x2a, 0x09, 0xd7, 0x42, 0x26, 0xdb, 0x9d, - 0x48, 0x54, 0x4e, 0xa2, 0x82, 0x25, 0xfe, 0x95, 0x01, 0x15, 0x29, 0x94, 0xb2, 0x19, 0xfa, 0x28, - 0x25, 0xd5, 0x46, 0x20, 0x55, 0xdc, 0xa6, 0x77, 0x8b, 0x85, 0x3e, 0x86, 0x32, 0x0f, 0xc4, 0x6a, - 0xad, 0x4a, 0x36, 0xda, 0x56, 0xa1, 0xb4, 0x24, 0xa2, 0xc0, 0xbf, 0x35, 0xa0, 0x79, 0xe8, 0xba, - 0x9c, 0x71, 0xdf, 0xf4, 0x32, 0x59, 0xe7, 0x09, 0x14, 0x18, 0x77, 0x7d, 0xaa, 0xef, 0xb0, 0xd6, - 0xd1, 0x7e, 0xd6, 0x17, 0x40, 0xa2, 0x70, 0xe8, 0x7b, 0x50, 0xf4, 0xe9, 0xc4, 0x72, 0x1d, 0x2d, - 0x52, 0x3d, 0xa0, 0x22, 0x12, 0x4a, 0x34, 0x16, 0x77, 0xe1, 0x41, 0x4c, 0x9a, 0x2c, 0x66, 0xc1, - 0xc7, 0xb0, 0x79, 0xca, 0x42, 0x26, 0x1e, 0x1d, 0x67, 0xd1, 0x0a, 0xff, 0x02, 0xb6, 0xd2, 0x5c, - 0x32, 0x5d, 0x12, 0x86, 0xea, 0x45, 0x8c, 0x8b, 0x34, 0x52, 0x89, 0x24, 0x60, 0xf8, 0x73, 0xa8, - 0x77, 0x6d, 0xdb, 0x1d, 0x9d, 0x1e, 0x67, 0x12, 0xb5, 0x07, 0x8d, 0x70, 0x7b, 0x26, 0x19, 0xeb, - 0x90, 0xb3, 0x94, 0x64, 0x79, 0x92, 0xb3, 0xc6, 0xf8, 0x1b, 0x68, 0x3c, 0xa7, 0x5c, 0xdd, 0x5f, - 0x16, 0x8f, 0x78, 0x08, 0x25, 0x79, 0xeb, 0xc3, 0x90, 0xeb, 0x9a, 0x5c, 0x9f, 0x8e, 0x31, 0x85, - 0x66, 0xc4, 0x3a, 0x93, 0xb0, 0xf7, 0x71, 0x37, 0x3c, 0x82, 0xc6, 0xf9, 0xec, 0x1d, 0x34, 0xb8, - 0xd7, 0x21, 0x5f, 0x40, 0x33, 0x3a, 0x24, 0x93, 0xab, 0x1e, 0xc2, 0xfa, 0x73, 0xca, 0xbb, 0xb6, - 0x2d, 0x99, 0xb0, 0x4c, 0xb7, 0x7f, 0x0d, 0x1b, 0x49, 0x1e, 0x99, 0xac, 0xfa, 0x5d, 0x28, 0x4a, - 0xa5, 0x58, 0x2b, 0xb7, 0xb7, 0xba, 0xa8, 0xb1, 0x46, 0xe2, 0x9f, 0xc9, 0xeb, 0xd3, 0x31, 0x9b, - 0xc5, 0xb0, 0x3b, 0x00, 0x2a, 0xd2, 0x87, 0xd7, 0x74, 0x2e, 0xad, 0x5b, 0x25, 0x65, 0x05, 0x79, - 0x49, 0xe7, 0xf8, 0x77, 0x06, 0x3c, 0x88, 0x1d, 0x90, 0x49, 0x95, 0x28, 0xd5, 0xe4, 0xee, 0x4a, - 0x35, 0xe8, 0x7d, 0x28, 0xda, 0x8a, 0xab, 0x4a, 0x49, 0xd5, 0x80, 0xee, 0x9c, 0x0a, 0x6e, 0x0a, - 0x87, 0x7f, 0x2e, 0xcd, 0xab, 0xb6, 0x1e, 0xce, 0xb3, 0x45, 0x28, 0x7a, 0x04, 0x5a, 0xc7, 0x28, - 0x22, 0x4a, 0x0a, 0x70, 0x3a, 0xc6, 0xcf, 0x60, 0xfb, 0x39, 0xe5, 0x47, 0xea, 0x4d, 0x3c, 0x72, - 0x9d, 0x4b, 0x6b, 0x92, 0xc9, 0x11, 0x18, 0xb4, 0x16, 0xf9, 0x64, 0xb2, 0xe0, 0x07, 0xb0, 0xa6, - 0x9f, 0x68, 0x6d, 0xc2, 0x46, 0x60, 0x1a, 0xcd, 0x9d, 0x04, 0x78, 0xfc, 0x2d, 0x6c, 0x9f, 0xcf, - 0xde, 0x5d, 0xf8, 0xff, 0xe6, 0xc8, 0x17, 0xd0, 0x5a, 0x3c, 0x32, 0x53, 0xf8, 0xfd, 0xc1, 0x80, - 0xe2, 0x2b, 0x3a, 0xbd, 0xa0, 0x3e, 0x42, 0x90, 0x77, 0xcc, 0xa9, 0x2a, 0x2e, 0xca, 0x44, 0x7e, - 0x8b, 0x5b, 0x9b, 0x4a, 0x6c, 0xec, 0xd6, 0x14, 0xe0, 0x74, 0x2c, 0x90, 0x1e, 0xa5, 0xfe, 0x70, - 0xe6, 0xdb, 0xac, 0xb5, 0xba, 0xb7, 0xba, 0x5f, 0x26, 0x25, 0x01, 0xf8, 0xca, 0xb7, 0x19, 0xfa, - 0x0e, 0x54, 0x46, 0xb6, 0x45, 0x1d, 0xae, 0xd0, 0x79, 0x89, 0x06, 0x05, 0x92, 0x04, 0xdf, 0x87, - 0x86, 0xf2, 0xaf, 0xa1, 0xe7, 0x5b, 0xae, 0x6f, 0xf1, 0x79, 0xab, 0xb0, 0x67, 0xec, 0x17, 0x48, - 0x5d, 0x81, 0xcf, 0x35, 0x14, 0x7f, 0x21, 0xe3, 0x41, 0x09, 0x99, 0x2d, 0x3f, 0xfc, 0xc5, 0x00, - 0x14, 0x67, 0x91, 0x31, 0xa6, 0xd6, 0x94, 0xe6, 0x41, 0x7e, 0xa8, 0x2a, 0x72, 0xc5, 0x95, 0x04, - 0xc8, 0x25, 0x31, 0x15, 0x27, 0xd3, 0x38, 0xf4, 0x31, 0x54, 0x28, 0x1f, 0x8d, 0x87, 0x9a, 0x34, - 0xbf, 0x84, 0x14, 0x04, 0xc1, 0x97, 0x4a, 0x83, 0x73, 0x28, 0x8b, 0x90, 0xec, 0x73, 0x93, 0x33, - 0xb4, 0x07, 0x79, 0x61, 0x66, 0x2d, 0x75, 0x32, 0x66, 0x25, 0x06, 0xbd, 0x07, 0xd5, 0xb1, 0x7b, - 0xe3, 0x0c, 0x19, 0x1d, 0xb9, 0xce, 0x98, 0xe9, 0x9b, 0xab, 0x08, 0x58, 0x5f, 0x81, 0xf0, 0x5f, - 0x57, 0x61, 0x4b, 0x85, 0xf4, 0x0b, 0x6a, 0xfa, 0xfc, 0x82, 0x9a, 0x3c, 0x93, 0xd7, 0xfe, 0x4f, - 0x53, 0x0d, 0xea, 0x00, 0x48, 0xc1, 0x85, 0x16, 0xca, 0x69, 0xc2, 0xd2, 0x2d, 0xd4, 0x9f, 0x94, - 0x05, 0x89, 0x58, 0x32, 0xf4, 0x09, 0xd4, 0x3c, 0xea, 0x8c, 0x2d, 0x67, 0xa2, 0xb7, 0x14, 0xf4, - 0xd5, 0xc4, 0x99, 0x57, 0x35, 0x89, 0xda, 0xf2, 0x04, 0x6a, 0x17, 0x73, 0x4e, 0xd9, 0xf0, 0xc6, - 0xb7, 0x38, 0xa7, 0x4e, 0xab, 0x28, 0x8d, 0x53, 0x95, 0xc0, 0xaf, 0x15, 0x4c, 0xe4, 0x68, 0x45, - 0xe4, 0x53, 0x73, 0xdc, 0x5a, 0x53, 0x35, 0xbb, 0x84, 0x10, 0x6a, 0x8a, 0x9a, 0xbd, 0x7a, 0x4d, - 0xe7, 0x11, 0x8b, 0x92, 0xb2, 0xaf, 0x80, 0x05, 0x1c, 0x1e, 0x41, 0x59, 0x92, 0x48, 0x06, 0x65, - 0x15, 0x39, 0x02, 0x20, 0xf7, 0x7f, 0x00, 0x4d, 0xd3, 0xf3, 0x7c, 0xf7, 0x97, 0xd6, 0xd4, 0xe4, - 0x74, 0xc8, 0xac, 0x37, 0xb4, 0x05, 0x92, 0xa6, 0x11, 0x83, 0xf7, 0xad, 0x37, 0x14, 0x3d, 0x8e, - 0xd7, 0xb2, 0x15, 0x25, 0x48, 0x54, 0xba, 0x5e, 0x01, 0x1c, 0x5d, 0x99, 0xce, 0x84, 0x0a, 0xdd, - 0xee, 0xe1, 0x18, 0x9f, 0x42, 0x65, 0x24, 0xe9, 0x87, 0xb2, 0x8f, 0xc8, 0xc9, 0x3e, 0x62, 0xbb, - 0x13, 0x34, 0x42, 0x22, 0x95, 0x28, 0x7e, 0xb2, 0x9f, 0x80, 0x51, 0xf8, 0x8d, 0x0f, 0xa0, 0x3e, - 0xf0, 0x4d, 0x87, 0x5d, 0x52, 0x5f, 0xf9, 0xe4, 0x7f, 0x3e, 0x0d, 0xff, 0x39, 0x07, 0xdb, 0x0b, - 0x3e, 0x96, 0x29, 0xf8, 0x3e, 0x09, 0xe5, 0x96, 0x47, 0x2a, 0x57, 0x6b, 0xaa, 0x2d, 0x91, 0x01, - 0x02, 0x81, 0xa5, 0x31, 0x3e, 0x87, 0x06, 0xd7, 0x02, 0x0f, 0x13, 0x9e, 0xa7, 0x4f, 0x4a, 0x6a, - 0x43, 0xea, 0x3c, 0xa9, 0x5d, 0xe2, 0xbd, 0xca, 0x27, 0xdf, 0x2b, 0xf4, 0x63, 0xa8, 0x6a, 0x24, - 0xf5, 0xdc, 0xd1, 0x95, 0x4c, 0x5c, 0x22, 0x4e, 0x12, 0xae, 0x7f, 0x22, 0x50, 0xa4, 0xe2, 0x47, - 0x0b, 0x11, 0xf5, 0xdc, 0xf4, 0x27, 0x94, 0x2b, 0x35, 0x8a, 0x4b, 0x2c, 0x07, 0x8a, 0x40, 0x7c, - 0xe3, 0x4b, 0x68, 0x74, 0xd9, 0x75, 0xdf, 0xb3, 0xad, 0xff, 0x6b, 0x6c, 0xe2, 0x5f, 0x1b, 0xd0, - 0x8c, 0x0e, 0xca, 0x58, 0xe3, 0xd7, 0x1c, 0x7a, 0x33, 0x4c, 0x3f, 0xf1, 0x15, 0x87, 0xde, 0x90, - 0xc0, 0x6a, 0x7b, 0x50, 0x15, 0x34, 0xf2, 0xcd, 0xb0, 0xc6, 0xea, 0xc9, 0xc8, 0x13, 0x70, 0xe8, - 0x8d, 0xd0, 0xf6, 0x74, 0xcc, 0xf0, 0x6f, 0x0c, 0x40, 0x84, 0x7a, 0xae, 0xcf, 0xb3, 0x2b, 0x8d, - 0x21, 0x6f, 0xd3, 0x4b, 0x7e, 0x8b, 0xca, 0x12, 0x87, 0xde, 0x87, 0x82, 0x6f, 0x4d, 0xae, 0xf8, - 0x2d, 0x9d, 0x98, 0x42, 0xe2, 0x23, 0x58, 0x4f, 0x08, 0x93, 0xe9, 0x81, 0xfd, 0xd7, 0x2a, 0x80, - 0x2c, 0x20, 0x55, 0xee, 0x8e, 0xf7, 0x05, 0x46, 0xa2, 0x2f, 0x10, 0xfd, 0xf3, 0xc8, 0xf4, 0xcc, - 0x91, 0x78, 0x09, 0xf5, 0x53, 0x1b, 0xac, 0x45, 0x16, 0x30, 0x5f, 0x9b, 0x96, 0x6d, 0x5e, 0xd8, - 0x54, 0x0a, 0x9d, 0x27, 0x11, 0x40, 0xa4, 0x23, 0x6d, 0x78, 0xd5, 0x0c, 0xe7, 0x65, 0x33, 0xac, - 0x3d, 0xef, 0x48, 0xb6, 0xc4, 0x1f, 0x01, 0x62, 0x3a, 0x51, 0x32, 0xc7, 0xf4, 0x34, 0x61, 0x41, - 0x12, 0x36, 0x35, 0xa6, 0xef, 0x98, 0x9e, 0xa2, 0x7e, 0x0a, 0x1b, 0x3e, 0x1d, 0x51, 0xeb, 0x75, - 0x8a, 0xbe, 0x28, 0xe9, 0x51, 0x88, 0x8b, 0x76, 0xec, 0x00, 0x30, 0x6e, 0xfa, 0x7c, 0x28, 0x72, - 0x93, 0x4c, 0x98, 0x35, 0x52, 0x96, 0x10, 0xd1, 0x72, 0xa3, 0x0e, 0xac, 0x9b, 0x9e, 0x67, 0xcf, - 0x53, 0xfc, 0x4a, 0x92, 0xee, 0x41, 0x80, 0x8a, 0xd8, 0x6d, 0xc3, 0x9a, 0xc5, 0x86, 0x17, 0x33, - 0x36, 0x97, 0xb9, 0xb3, 0x44, 0x8a, 0x16, 0x3b, 0x9c, 0xb1, 0xb9, 0x08, 0xcb, 0x19, 0xa3, 0xe3, - 0x78, 0xca, 0x2c, 0x09, 0x80, 0xcc, 0x95, 0x0b, 0xa9, 0xbd, 0xb2, 0x24, 0xb5, 0xa7, 0x73, 0x77, - 0x75, 0x31, 0x77, 0x27, 0xb3, 0x7f, 0x2d, 0x9d, 0xfd, 0x13, 0xa9, 0xbd, 0x9e, 0x4c, 0xed, 0xd8, - 0x86, 0x4d, 0x79, 0xdd, 0xef, 0xfa, 0xaa, 0x16, 0x98, 0xf0, 0x97, 0x64, 0xa6, 0x8b, 0xfc, 0x88, - 0x28, 0x34, 0x7e, 0x06, 0x5b, 0xe9, 0xd3, 0x32, 0x79, 0xe9, 0x9f, 0x0c, 0xd8, 0xe8, 0x8f, 0x4c, - 0x2e, 0xaa, 0xcc, 0xec, 0x9d, 0xcd, 0x5d, 0x35, 0xfe, 0x7d, 0xc7, 0x1f, 0xb1, 0x42, 0x21, 0x7f, - 0x47, 0x4f, 0x72, 0x02, 0x9b, 0x29, 0x79, 0xb3, 0xe8, 0xfd, 0x21, 0x85, 0x72, 0x38, 0x3e, 0x43, - 0x45, 0xc8, 0xf5, 0x5e, 0x36, 0x57, 0x50, 0x05, 0xd6, 0xbe, 0x3a, 0x7b, 0x79, 0xd6, 0xfb, 0xfa, - 0xac, 0x69, 0xa0, 0x0d, 0x68, 0x9e, 0xf5, 0x06, 0xc3, 0xc3, 0x5e, 0x6f, 0xd0, 0x1f, 0x90, 0xee, - 0xf9, 0xf9, 0xc9, 0x71, 0x33, 0x87, 0xd6, 0xa1, 0xd1, 0x1f, 0xf4, 0xc8, 0xc9, 0x70, 0xd0, 0x7b, - 0x75, 0xd8, 0x1f, 0xf4, 0xce, 0x4e, 0x9a, 0xab, 0xa8, 0x05, 0x1b, 0xdd, 0x2f, 0xc9, 0x49, 0xf7, - 0xf8, 0x9b, 0x24, 0x79, 0xfe, 0xe0, 0x8f, 0x65, 0xc8, 0x9d, 0x1f, 0xa3, 0x2e, 0x40, 0x54, 0x86, - 0xa2, 0x6d, 0x25, 0xd9, 0x42, 0x6d, 0xdb, 0x6e, 0x2d, 0x22, 0x94, 0xf0, 0x78, 0x05, 0x3d, 0x85, - 0xd5, 0x01, 0x73, 0x91, 0x76, 0x88, 0x68, 0x9a, 0xd7, 0x7e, 0x10, 0x83, 0x04, 0xd4, 0xfb, 0xc6, - 0x53, 0x03, 0xfd, 0x04, 0xca, 0xe1, 0x0c, 0x07, 0x6d, 0x29, 0xaa, 0xf4, 0xb4, 0xab, 0xbd, 0xbd, - 0x00, 0x0f, 0x4f, 0x7c, 0x05, 0xf5, 0xe4, 0x14, 0x08, 0x3d, 0x52, 0xc4, 0x4b, 0x27, 0x4c, 0xed, - 0xc7, 0xcb, 0x91, 0x21, 0xbb, 0x4f, 0x61, 0x4d, 0x4f, 0x6a, 0x90, 0xbe, 0x9a, 0xe4, 0xdc, 0xa7, - 0xbd, 0x99, 0x82, 0x86, 0x3b, 0x3f, 0x83, 0x52, 0x30, 0x37, 0x41, 0x9b, 0xa1, 0x89, 0xe2, 0x03, - 0x8e, 0xf6, 0x56, 0x1a, 0x1c, 0xdf, 0x1c, 0x0c, 0x2a, 0x82, 0xcd, 0xa9, 0xe9, 0x48, 0xb0, 0x39, - 0x3d, 0xcf, 0xc0, 0x2b, 0xe8, 0x39, 0x54, 0xe3, 0xf3, 0x05, 0xf4, 0x30, 0x3c, 0x26, 0x3d, 0xb7, - 0x68, 0xb7, 0x97, 0xa1, 0xe2, 0xb6, 0x4c, 0x86, 0x6b, 0x60, 0xcb, 0xa5, 0x29, 0x23, 0xb0, 0xe5, - 0xf2, 0x08, 0xc7, 0x2b, 0x68, 0x00, 0x8d, 0x54, 0x79, 0x85, 0x1e, 0x07, 0xee, 0xbe, 0xac, 0xb2, - 0x6f, 0xef, 0xdc, 0x82, 0x4d, 0x3b, 0x4c, 0xd8, 0xee, 0xa3, 0xc8, 0xa2, 0x89, 0xbc, 0xd0, 0xde, - 0x5e, 0x80, 0x87, 0x52, 0x3d, 0x83, 0x5a, 0x62, 0x5c, 0x80, 0xda, 0x29, 0xda, 0xd8, 0x0c, 0xe1, - 0x2e, 0x3e, 0x9f, 0x41, 0x29, 0x28, 0x4a, 0x82, 0x2b, 0x4b, 0x55, 0x43, 0xc1, 0x95, 0xa5, 0x6b, - 0x17, 0xbc, 0x82, 0x8e, 0xa1, 0x12, 0x7b, 0xbb, 0x51, 0x2b, 0x50, 0x3c, 0x5d, 0x5b, 0xb4, 0x1f, - 0x2e, 0xc1, 0x84, 0x5c, 0xfa, 0x72, 0xd6, 0x93, 0xe8, 0xb3, 0xd1, 0x4e, 0x28, 0xf1, 0xb2, 0x96, - 0xbf, 0xbd, 0x7b, 0x1b, 0x3a, 0xce, 0x34, 0xdd, 0xbc, 0x07, 0x4c, 0x6f, 0x99, 0x23, 0x04, 0x4c, - 0x6f, 0xeb, 0xf9, 0xf1, 0x0a, 0xfa, 0x29, 0xd4, 0x12, 0xf9, 0x30, 0x30, 0xfa, 0xb2, 0xa4, 0xde, - 0x7e, 0xb4, 0x14, 0x17, 0xf0, 0x3a, 0xfc, 0xf0, 0x6f, 0x6f, 0x77, 0x8d, 0xbf, 0xbf, 0xdd, 0x35, - 0xfe, 0xf1, 0x76, 0xd7, 0xf8, 0xfd, 0x3f, 0x77, 0x57, 0xa0, 0x35, 0x72, 0xa7, 0x1d, 0xcf, 0x72, - 0x26, 0x23, 0xd3, 0xeb, 0x70, 0xeb, 0xfa, 0x75, 0xe7, 0xfa, 0xb5, 0xfc, 0x7b, 0xe4, 0xa2, 0x28, - 0x7f, 0x7e, 0xf4, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xab, 0x35, 0x0b, 0x39, 0x6c, 0x19, 0x00, - 0x00, + // 2010 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x19, 0x4d, 0x73, 0x23, 0x47, + 0xd5, 0xa3, 0x2f, 0x4b, 0x4f, 0x9f, 0x6e, 0xcb, 0xb6, 0x56, 0xbb, 0x36, 0x4e, 0x6f, 0x00, 0x27, + 0x24, 0x62, 0x63, 0xaa, 0xa8, 0x54, 0xa5, 0x42, 0xc5, 0x5f, 0xbb, 0x6b, 0x36, 0x6b, 0x99, 0x96, + 0x36, 0xa9, 0x5c, 0x10, 0x63, 0xa9, 0x2d, 0x0f, 0x1e, 0xcf, 0x4c, 0xa6, 0x5b, 0x36, 0xca, 0x89, + 0x13, 0x17, 0xa8, 0xe2, 0xca, 0x91, 0x5f, 0xc0, 0x3f, 0xa0, 0x38, 0x70, 0xe1, 0xc8, 0x4f, 0xa0, + 0x96, 0x33, 0x37, 0x7e, 0x00, 0xd5, 0xdd, 0xd3, 0xa3, 0x99, 0x91, 0x6c, 0x9c, 0xd9, 0xcd, 0x49, + 0xd3, 0xef, 0xbd, 0x7e, 0xfd, 0xde, 0xeb, 0xf7, 0xd1, 0xef, 0x09, 0xc0, 0x1b, 0x79, 0x67, 0x1d, + 0xcf, 0x77, 0xb9, 0x8b, 0x72, 0xe2, 0xbb, 0x5d, 0xb9, 0xa2, 0xdc, 0xd4, 0xb0, 0x76, 0x95, 0xfa, + 0xe6, 0x39, 0x0f, 0x97, 0xcd, 0xb1, 0x3b, 0x76, 0xe5, 0xe7, 0x8f, 0xc5, 0x97, 0x82, 0xe2, 0x0e, + 0x54, 0x09, 0xfd, 0x7a, 0x42, 0x19, 0x7f, 0x4e, 0xcd, 0x11, 0xf5, 0xd1, 0x26, 0xc0, 0xd0, 0x9e, + 0x30, 0x4e, 0xfd, 0x81, 0x35, 0x6a, 0x19, 0xdb, 0xc6, 0x4e, 0x8e, 0x94, 0x02, 0xc8, 0xf1, 0x08, + 0x13, 0xa8, 0x11, 0xca, 0x3c, 0xd7, 0x61, 0xf4, 0x5e, 0x1b, 0xd0, 0x3b, 0x90, 0xa7, 0xbe, 0xef, + 0xfa, 0xad, 0xcc, 0xb6, 0xb1, 0x53, 0xde, 0x2d, 0x77, 0xa4, 0xd4, 0x47, 0x02, 0x44, 0x14, 0x06, + 0x3f, 0x85, 0xbc, 0x5c, 0xa3, 0xc7, 0x90, 0xe3, 0x53, 0x8f, 0x4a, 0x26, 0xb5, 0xdd, 0x7a, 0x84, + 0xb4, 0x3f, 0xf5, 0x28, 0x91, 0x48, 0xd4, 0x82, 0xe5, 0x2b, 0xca, 0x98, 0x39, 0xa6, 0x92, 0x65, + 0x89, 0xe8, 0x25, 0xee, 0x02, 0xf4, 0x99, 0x1b, 0xa8, 0x83, 0x7e, 0x04, 0x85, 0x0b, 0x29, 0xa1, + 0x64, 0x57, 0xde, 0x5d, 0x55, 0xec, 0x62, 0xda, 0x92, 0x80, 0x04, 0x35, 0x21, 0x3f, 0x74, 0x27, + 0x0e, 0x97, 0x2c, 0xab, 0x44, 0x2d, 0xf0, 0x1e, 0x94, 0xfa, 0xd6, 0x15, 0x65, 0xdc, 0xbc, 0xf2, + 0x50, 0x1b, 0x8a, 0xde, 0xc5, 0x94, 0x59, 0x43, 0xd3, 0x96, 0x1c, 0xb3, 0x24, 0x5c, 0x0b, 0x99, + 0x6c, 0x77, 0x2c, 0x51, 0x19, 0x89, 0xd2, 0x4b, 0xfc, 0x5b, 0x03, 0xca, 0x52, 0x28, 0x65, 0x33, + 0xf4, 0x41, 0x42, 0xaa, 0xa6, 0x96, 0x2a, 0x6a, 0xd3, 0xbb, 0xc5, 0x42, 0x1f, 0x42, 0x89, 0x6b, + 0xb1, 0x5a, 0x59, 0xc9, 0x26, 0xb0, 0x55, 0x28, 0x2d, 0x99, 0x51, 0xe0, 0x3f, 0x18, 0xd0, 0xd8, + 0x77, 0x5d, 0xce, 0xb8, 0x6f, 0x7a, 0xa9, 0xac, 0xf3, 0x18, 0xf2, 0x8c, 0xbb, 0x3e, 0x0d, 0xee, + 0xb0, 0xda, 0x09, 0xfc, 0xac, 0x27, 0x80, 0x44, 0xe1, 0xd0, 0x0f, 0xa0, 0xe0, 0xd3, 0xb1, 0xe5, + 0x3a, 0x81, 0x48, 0x35, 0x4d, 0x45, 0x24, 0x94, 0x04, 0x58, 0xbc, 0x07, 0x2b, 0x11, 0x69, 0xd2, + 0x98, 0x05, 0x1f, 0xc2, 0xda, 0x31, 0x0b, 0x99, 0x78, 0x74, 0x94, 0x46, 0x2b, 0xfc, 0x6b, 0x58, + 0x4f, 0x72, 0x49, 0x75, 0x49, 0x18, 0x2a, 0x67, 0x11, 0x2e, 0xd2, 0x48, 0x45, 0x12, 0x83, 0xe1, + 0x4f, 0xa1, 0xb6, 0x67, 0xdb, 0xee, 0xf0, 0xf8, 0x30, 0x95, 0xa8, 0x5d, 0xa8, 0x87, 0xdb, 0x53, + 0xc9, 0x58, 0x83, 0x8c, 0xa5, 0x24, 0xcb, 0x91, 0x8c, 0x35, 0xc2, 0x5f, 0x41, 0xfd, 0x19, 0xe5, + 0xea, 0xfe, 0xd2, 0x78, 0xc4, 0x03, 0x28, 0xca, 0x5b, 0x1f, 0x84, 0x5c, 0x97, 0xe5, 0xfa, 0x78, + 0x84, 0x29, 0x34, 0x66, 0xac, 0x53, 0x09, 0x7b, 0x1f, 0x77, 0xc3, 0x43, 0xa8, 0x9f, 0x4e, 0xde, + 0x40, 0x83, 0x7b, 0x1d, 0xf2, 0x19, 0x34, 0x66, 0x87, 0xa4, 0x72, 0xd5, 0x7d, 0x58, 0x7d, 0x46, + 0xf9, 0x9e, 0x6d, 0x4b, 0x26, 0x2c, 0xd5, 0xed, 0x5f, 0x42, 0x33, 0xce, 0x23, 0x95, 0x55, 0xbf, + 0x0f, 0x05, 0xa9, 0x14, 0x6b, 0x65, 0xb6, 0xb3, 0xf3, 0x1a, 0x07, 0x48, 0xfc, 0x4b, 0x79, 0x7d, + 0x41, 0xcc, 0xa6, 0x31, 0xec, 0x26, 0x80, 0x8a, 0xf4, 0xc1, 0x25, 0x9d, 0x4a, 0xeb, 0x56, 0x48, + 0x49, 0x41, 0x5e, 0xd0, 0x29, 0xfe, 0xa3, 0x01, 0x2b, 0x91, 0x03, 0x52, 0xa9, 0x32, 0x4b, 0x35, + 0x99, 0xbb, 0x52, 0x0d, 0x7a, 0x17, 0x0a, 0xb6, 0xe2, 0xaa, 0x52, 0x52, 0x45, 0xd3, 0x9d, 0x52, + 0xc1, 0x4d, 0xe1, 0xf0, 0xaf, 0xa4, 0x79, 0xd5, 0xd6, 0xfd, 0x69, 0xba, 0x08, 0x45, 0x0f, 0x21, + 0xd0, 0x71, 0x16, 0x11, 0x45, 0x05, 0x38, 0x1e, 0xe1, 0xa7, 0xb0, 0xf1, 0x8c, 0xf2, 0x03, 0x55, + 0x13, 0x0f, 0x5c, 0xe7, 0xdc, 0x1a, 0xa7, 0x72, 0x04, 0x06, 0xad, 0x79, 0x3e, 0xa9, 0x2c, 0xf8, + 0x1e, 0x2c, 0x07, 0x25, 0x3a, 0x30, 0x61, 0x5d, 0x9b, 0x26, 0xe0, 0x4e, 0x34, 0x1e, 0x7f, 0x0d, + 0x1b, 0xa7, 0x93, 0x37, 0x17, 0xfe, 0xdb, 0x1c, 0xf9, 0x1c, 0x5a, 0xf3, 0x47, 0xa6, 0x0a, 0xbf, + 0x3f, 0x1b, 0x50, 0x78, 0x49, 0xaf, 0xce, 0xa8, 0x8f, 0x10, 0xe4, 0x1c, 0xf3, 0x4a, 0x3d, 0x2e, + 0x4a, 0x44, 0x7e, 0x8b, 0x5b, 0xbb, 0x92, 0xd8, 0xc8, 0xad, 0x29, 0xc0, 0xf1, 0x48, 0x20, 0x3d, + 0x4a, 0xfd, 0xc1, 0xc4, 0xb7, 0x59, 0x2b, 0xbb, 0x9d, 0xdd, 0x29, 0x91, 0xa2, 0x00, 0xbc, 0xf2, + 0x6d, 0x86, 0xbe, 0x07, 0xe5, 0xa1, 0x6d, 0x51, 0x87, 0x2b, 0x74, 0x4e, 0xa2, 0x41, 0x81, 0x24, + 0xc1, 0x0f, 0xa1, 0xae, 0xfc, 0x6b, 0xe0, 0xf9, 0x96, 0xeb, 0x5b, 0x7c, 0xda, 0xca, 0x6f, 0x1b, + 0x3b, 0x79, 0x52, 0x53, 0xe0, 0xd3, 0x00, 0x8a, 0x3f, 0x93, 0xf1, 0xa0, 0x84, 0x4c, 0x97, 0x1f, + 0xfe, 0x66, 0x00, 0x8a, 0xb2, 0x48, 0x19, 0x53, 0xcb, 0x4a, 0x73, 0x9d, 0x1f, 0x2a, 0x8a, 0x5c, + 0x71, 0x25, 0x1a, 0xb9, 0x20, 0xa6, 0xa2, 0x64, 0x01, 0x0e, 0x7d, 0x08, 0x65, 0xca, 0x87, 0xa3, + 0x41, 0x40, 0x9a, 0x5b, 0x40, 0x0a, 0x82, 0xe0, 0x73, 0xa5, 0xc1, 0x29, 0x94, 0x44, 0x48, 0xf6, + 0xb8, 0xc9, 0x19, 0xda, 0x86, 0x9c, 0x30, 0x73, 0x20, 0x75, 0x3c, 0x66, 0x25, 0x06, 0xbd, 0x03, + 0x95, 0x91, 0x7b, 0xe3, 0x0c, 0x18, 0x1d, 0xba, 0xce, 0x88, 0x05, 0x37, 0x57, 0x16, 0xb0, 0x9e, + 0x02, 0xe1, 0xbf, 0x67, 0x61, 0x5d, 0x85, 0xf4, 0x73, 0x6a, 0xfa, 0xfc, 0x8c, 0x9a, 0x3c, 0x95, + 0xd7, 0xbe, 0xd5, 0x54, 0x83, 0x3a, 0x00, 0x52, 0x70, 0xa1, 0x85, 0x72, 0x9a, 0xf0, 0xe9, 0x16, + 0xea, 0x4f, 0x4a, 0x82, 0x44, 0x2c, 0x19, 0xfa, 0x08, 0xaa, 0x1e, 0x75, 0x46, 0x96, 0x33, 0x0e, + 0xb6, 0xe4, 0x83, 0xab, 0x89, 0x32, 0xaf, 0x04, 0x24, 0x6a, 0xcb, 0x63, 0xa8, 0x9e, 0x4d, 0x39, + 0x65, 0x83, 0x1b, 0xdf, 0xe2, 0x9c, 0x3a, 0xad, 0x82, 0x34, 0x4e, 0x45, 0x02, 0xbf, 0x54, 0x30, + 0x91, 0xa3, 0x15, 0x91, 0x4f, 0xcd, 0x51, 0x6b, 0x59, 0xbd, 0xd9, 0x25, 0x84, 0x50, 0x53, 0xbc, + 0xd9, 0x2b, 0x97, 0x74, 0x3a, 0x63, 0x51, 0x54, 0xf6, 0x15, 0x30, 0xcd, 0xe1, 0x21, 0x94, 0x24, + 0x89, 0x64, 0x50, 0x52, 0x91, 0x23, 0x00, 0x72, 0xff, 0x7b, 0xd0, 0x30, 0x3d, 0xcf, 0x77, 0x7f, + 0x63, 0x5d, 0x99, 0x9c, 0x0e, 0x98, 0xf5, 0x0d, 0x6d, 0x81, 0xa4, 0xa9, 0x47, 0xe0, 0x3d, 0xeb, + 0x1b, 0x8a, 0x1e, 0x45, 0xdf, 0xb2, 0x65, 0x25, 0xc8, 0xec, 0xe9, 0x7a, 0x01, 0x70, 0x70, 0x61, + 0x3a, 0x63, 0x2a, 0x74, 0xbb, 0x87, 0x63, 0x7c, 0x0c, 0xe5, 0xa1, 0xa4, 0x1f, 0xc8, 0x3e, 0x22, + 0x23, 0xfb, 0x88, 0x8d, 0x8e, 0x6e, 0x84, 0x44, 0x2a, 0x51, 0xfc, 0x64, 0x3f, 0x01, 0xc3, 0xf0, + 0x1b, 0xef, 0x42, 0xad, 0xef, 0x9b, 0x0e, 0x3b, 0xa7, 0xbe, 0xf2, 0xc9, 0xff, 0x7f, 0x1a, 0xfe, + 0x6b, 0x06, 0x36, 0xe6, 0x7c, 0x2c, 0x55, 0xf0, 0x7d, 0x14, 0xca, 0x2d, 0x8f, 0x54, 0xae, 0xd6, + 0x50, 0x5b, 0x66, 0x06, 0xd0, 0x02, 0x4b, 0x63, 0x7c, 0x0a, 0x75, 0x1e, 0x08, 0x3c, 0x88, 0x79, + 0x5e, 0x70, 0x52, 0x5c, 0x1b, 0x52, 0xe3, 0x71, 0xed, 0x62, 0xf5, 0x2a, 0x17, 0xaf, 0x57, 0xe8, + 0xa7, 0x50, 0x09, 0x90, 0xd4, 0x73, 0x87, 0x17, 0x32, 0x71, 0x89, 0x38, 0x89, 0xb9, 0xfe, 0x91, + 0x40, 0x91, 0xb2, 0x3f, 0x5b, 0x88, 0xa8, 0xe7, 0xa6, 0x3f, 0xa6, 0x5c, 0xa9, 0x51, 0x58, 0x60, + 0x39, 0x50, 0x04, 0xe2, 0x1b, 0x9f, 0x43, 0x7d, 0x8f, 0x5d, 0xf6, 0x3c, 0xdb, 0xfa, 0x4e, 0x63, + 0x13, 0xff, 0xce, 0x80, 0xc6, 0xec, 0xa0, 0x94, 0x6f, 0xfc, 0xaa, 0x43, 0x6f, 0x06, 0xc9, 0x12, + 0x5f, 0x76, 0xe8, 0x0d, 0xd1, 0x56, 0xdb, 0x86, 0x8a, 0xa0, 0x91, 0x35, 0xc3, 0x1a, 0xa9, 0x92, + 0x91, 0x23, 0xe0, 0xd0, 0x1b, 0xa1, 0xed, 0xf1, 0x88, 0xe1, 0xdf, 0x1b, 0x80, 0x08, 0xf5, 0x5c, + 0x9f, 0xa7, 0x57, 0x1a, 0x43, 0xce, 0xa6, 0xe7, 0xfc, 0x16, 0x95, 0x25, 0x0e, 0xbd, 0x0b, 0x79, + 0xdf, 0x1a, 0x5f, 0xf0, 0x5b, 0x3a, 0x31, 0x85, 0xc4, 0x07, 0xb0, 0x1a, 0x13, 0x26, 0x55, 0x81, + 0xfd, 0x4f, 0x16, 0x40, 0x3e, 0x20, 0x55, 0xee, 0x8e, 0xf6, 0x05, 0x46, 0xac, 0x2f, 0x10, 0xfd, + 0xf3, 0xd0, 0xf4, 0xcc, 0xa1, 0xa8, 0x84, 0x41, 0xa9, 0xd5, 0x6b, 0x91, 0x05, 0xcc, 0x6b, 0xd3, + 0xb2, 0xcd, 0x33, 0x9b, 0x4a, 0xa1, 0x73, 0x64, 0x06, 0x10, 0xe9, 0x28, 0x30, 0xbc, 0x6a, 0x86, + 0x73, 0xb2, 0x19, 0x0e, 0x3c, 0xef, 0x40, 0xb6, 0xc4, 0x1f, 0x00, 0x62, 0x41, 0xa2, 0x64, 0x8e, + 0xe9, 0x05, 0x84, 0x79, 0x49, 0xd8, 0x08, 0x30, 0x3d, 0xc7, 0xf4, 0x14, 0xf5, 0x13, 0x68, 0xfa, + 0x74, 0x48, 0xad, 0xeb, 0x04, 0x7d, 0x41, 0xd2, 0xa3, 0x10, 0x37, 0xdb, 0xb1, 0x09, 0xc0, 0xb8, + 0xe9, 0xf3, 0x81, 0xc8, 0x4d, 0x32, 0x61, 0x56, 0x49, 0x49, 0x42, 0x44, 0xcb, 0x8d, 0x3a, 0xb0, + 0x6a, 0x7a, 0x9e, 0x3d, 0x4d, 0xf0, 0x2b, 0x4a, 0xba, 0x15, 0x8d, 0x9a, 0xb1, 0xdb, 0x80, 0x65, + 0x8b, 0x0d, 0xce, 0x26, 0x6c, 0x2a, 0x73, 0x67, 0x91, 0x14, 0x2c, 0xb6, 0x3f, 0x61, 0x53, 0x11, + 0x96, 0x13, 0x46, 0x47, 0xd1, 0x94, 0x59, 0x14, 0x00, 0x99, 0x2b, 0xe7, 0x52, 0x7b, 0x79, 0x41, + 0x6a, 0x4f, 0xe6, 0xee, 0xca, 0x7c, 0xee, 0x8e, 0x67, 0xff, 0x6a, 0x32, 0xfb, 0xc7, 0x52, 0x7b, + 0x2d, 0x9e, 0xda, 0xb1, 0x0d, 0x6b, 0xf2, 0xba, 0xdf, 0xb4, 0xaa, 0xe6, 0x99, 0xf0, 0x97, 0x78, + 0xa6, 0x9b, 0xf9, 0x11, 0x51, 0x68, 0xfc, 0x14, 0xd6, 0x93, 0xa7, 0xa5, 0xf2, 0xd2, 0xbf, 0x18, + 0xd0, 0xec, 0x0d, 0x4d, 0x2e, 0x5e, 0x99, 0xe9, 0x3b, 0x9b, 0xbb, 0xde, 0xf8, 0xf7, 0x1d, 0x7f, + 0x44, 0x1e, 0x0a, 0xb9, 0x3b, 0x7a, 0x92, 0x23, 0x58, 0x4b, 0xc8, 0x9b, 0x4a, 0xef, 0x5f, 0xc8, + 0x66, 0xee, 0x15, 0xa3, 0xfe, 0x8b, 0x2f, 0x52, 0xa9, 0xdc, 0x80, 0xac, 0xee, 0xe2, 0x4a, 0x44, + 0x7c, 0x62, 0x4b, 0x3e, 0x57, 0x35, 0xcb, 0x54, 0xc9, 0x74, 0x8e, 0x29, 0x6a, 0x42, 0xfe, 0xda, + 0xb4, 0x27, 0x2a, 0xf6, 0x4b, 0x44, 0x2d, 0xf0, 0x58, 0x76, 0xdf, 0x6f, 0x53, 0xfa, 0x5b, 0x0e, + 0xb2, 0x60, 0x25, 0x72, 0xd0, 0x77, 0xaa, 0x53, 0x1f, 0x56, 0x0f, 0xa9, 0x4d, 0x39, 0x7d, 0xab, + 0x97, 0xf2, 0x05, 0x34, 0xe3, 0x5c, 0xdf, 0x8e, 0x0e, 0xef, 0x53, 0x28, 0x85, 0xe3, 0x57, 0x54, + 0x80, 0x4c, 0xf7, 0x45, 0x63, 0x09, 0x95, 0x61, 0xf9, 0xd5, 0xc9, 0x8b, 0x93, 0xee, 0x97, 0x27, + 0x0d, 0x03, 0x35, 0xa1, 0x71, 0xd2, 0xed, 0x0f, 0xf6, 0xbb, 0xdd, 0x7e, 0xaf, 0x4f, 0xf6, 0x4e, + 0x4f, 0x8f, 0x0e, 0x1b, 0x19, 0xb4, 0x0a, 0xf5, 0x5e, 0xbf, 0x4b, 0x8e, 0x06, 0xfd, 0xee, 0xcb, + 0xfd, 0x5e, 0xbf, 0x7b, 0x72, 0xd4, 0xc8, 0xa2, 0x16, 0x34, 0xf7, 0x3e, 0x27, 0x47, 0x7b, 0x87, + 0x5f, 0xc5, 0xc9, 0x73, 0xbb, 0xff, 0x05, 0xc8, 0x9c, 0x1e, 0xa2, 0x3d, 0x80, 0x59, 0x1b, 0x83, + 0x36, 0x94, 0xac, 0x73, 0xbd, 0x51, 0xbb, 0x35, 0x8f, 0x50, 0xea, 0xe0, 0x25, 0xf4, 0x04, 0xb2, + 0x7d, 0xe6, 0xa2, 0x20, 0xa1, 0xcc, 0xa6, 0xc1, 0xed, 0x95, 0x08, 0x44, 0x53, 0xef, 0x18, 0x4f, + 0x0c, 0xf4, 0x33, 0x28, 0x85, 0x33, 0x40, 0xb4, 0xae, 0xa8, 0x92, 0xd3, 0xd2, 0xf6, 0xc6, 0x1c, + 0x3c, 0x3c, 0xf1, 0x25, 0xd4, 0xe2, 0x53, 0x44, 0xf4, 0x50, 0x11, 0x2f, 0x9c, 0x50, 0xb6, 0x1f, + 0x2d, 0x46, 0x86, 0xec, 0x3e, 0x86, 0xe5, 0x60, 0xd2, 0x87, 0x82, 0xcb, 0x8a, 0xcf, 0x0d, 0xdb, + 0x6b, 0x09, 0x68, 0xb8, 0xf3, 0x13, 0x28, 0xea, 0xb9, 0x1b, 0x5a, 0x0b, 0x4d, 0x14, 0x1d, 0x90, + 0xb5, 0xd7, 0x93, 0xe0, 0xe8, 0x66, 0x3d, 0xe8, 0xd2, 0x9b, 0x13, 0xd3, 0x35, 0xbd, 0x39, 0x39, + 0x0f, 0xc3, 0x4b, 0xe8, 0x19, 0x54, 0xa2, 0xf3, 0x29, 0xf4, 0x20, 0x3c, 0x26, 0x39, 0xf7, 0x6a, + 0xb7, 0x17, 0xa1, 0xa2, 0xb6, 0x8c, 0xa7, 0x7b, 0x6d, 0xcb, 0x85, 0x25, 0x47, 0xdb, 0x72, 0x71, + 0x85, 0xc0, 0x4b, 0xa8, 0x0f, 0xf5, 0xc4, 0xf3, 0x1c, 0x3d, 0xd2, 0x01, 0xb0, 0xa8, 0x33, 0x6c, + 0x6f, 0xde, 0x82, 0x4d, 0x3a, 0x4c, 0x38, 0x2e, 0x42, 0x33, 0x8b, 0xc6, 0xea, 0x4a, 0x7b, 0x63, + 0x0e, 0x1e, 0x4a, 0xf5, 0x14, 0xaa, 0xb1, 0x71, 0x13, 0x6a, 0x27, 0x68, 0x23, 0x33, 0xa8, 0xbb, + 0xf8, 0x7c, 0x02, 0x45, 0xfd, 0xa8, 0xd5, 0x57, 0x96, 0x78, 0x4d, 0xeb, 0x2b, 0x4b, 0xbe, 0x7d, + 0xf1, 0x12, 0x3a, 0x84, 0x72, 0xe4, 0xed, 0x87, 0x5a, 0x5a, 0xf1, 0xe4, 0xdb, 0xb4, 0xfd, 0x60, + 0x01, 0x26, 0xe4, 0xd2, 0x93, 0xe5, 0x25, 0x36, 0xa7, 0x41, 0x9b, 0xa1, 0xc4, 0x8b, 0x46, 0x46, + 0xed, 0xad, 0xdb, 0xd0, 0x51, 0xa6, 0xc9, 0xe1, 0x8f, 0x66, 0x7a, 0xcb, 0x1c, 0x4a, 0x33, 0xbd, + 0x6d, 0x66, 0x84, 0x97, 0xd0, 0xcf, 0xa1, 0x1a, 0xab, 0xa7, 0xda, 0xe8, 0x8b, 0x1e, 0x05, 0xed, + 0x87, 0x0b, 0x71, 0x21, 0x2f, 0xe5, 0x00, 0x2a, 0xd3, 0x46, 0x1c, 0x20, 0x96, 0xd0, 0x23, 0x17, + 0x17, 0x4f, 0xc9, 0x6a, 0x7f, 0x58, 0x6d, 0xd0, 0x2c, 0xaa, 0x16, 0xee, 0x9f, 0x2b, 0x4b, 0x2a, + 0xdc, 0xa2, 0xc9, 0x5e, 0x87, 0xdb, 0x82, 0xb2, 0xa2, 0xc3, 0x6d, 0x51, 0x6d, 0xc0, 0x4b, 0xfb, + 0xef, 0xff, 0xe3, 0xf5, 0x96, 0xf1, 0xcf, 0xd7, 0x5b, 0xc6, 0xbf, 0x5e, 0x6f, 0x19, 0x7f, 0xfa, + 0xf7, 0xd6, 0x12, 0xb4, 0x86, 0xee, 0x55, 0xc7, 0xb3, 0x9c, 0xf1, 0xd0, 0xf4, 0x3a, 0xdc, 0xba, + 0xbc, 0xee, 0x5c, 0x5e, 0xcb, 0xff, 0x09, 0xcf, 0x0a, 0xf2, 0xe7, 0x27, 0xff, 0x0b, 0x00, 0x00, + 0xff, 0xff, 0xf8, 0xb9, 0x6c, 0x2f, 0x75, 0x1c, 0x00, 0x00, }