github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/rpc/heartbeat.pb.go (about)

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: rpc/heartbeat.proto
     3  
     4  package rpc
     5  
     6  import proto "github.com/gogo/protobuf/proto"
     7  import fmt "fmt"
     8  import math "math"
     9  import roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"
    10  
    11  import github_com_cockroachdb_cockroach_pkg_util_uuid "github.com/cockroachdb/cockroach/pkg/util/uuid"
    12  import github_com_cockroachdb_cockroach_pkg_roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"
    13  
    14  import (
    15  	context "context"
    16  	grpc "google.golang.org/grpc"
    17  )
    18  
    19  import io "io"
    20  
    21  // Reference imports to suppress errors if they are not otherwise used.
    22  var _ = proto.Marshal
    23  var _ = fmt.Errorf
    24  var _ = math.Inf
    25  
    26  // This is a compile-time assertion to ensure that this generated file
    27  // is compatible with the proto package it is being compiled against.
    28  // A compilation error at this line likely means your copy of the
    29  // proto package needs to be updated.
    30  const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
    31  
    32  // RemoteOffset keeps track of this client's estimate of its offset from a
    33  // remote server. Uncertainty is the maximum error in the reading of this
    34  // offset, so that the real offset should be in the interval
    35  // [Offset - Uncertainty, Offset + Uncertainty]. If the last heartbeat timed
    36  // out, Offset = 0.
    37  //
    38  // Offset and Uncertainty are measured using the remote clock reading technique
    39  // described in http://se.inf.tu-dresden.de/pubs/papers/SRDS1994.pdf, page 6.
    40  type RemoteOffset struct {
    41  	// The estimated offset from the remote server, in nanoseconds.
    42  	Offset int64 `protobuf:"varint,1,opt,name=offset" json:"offset"`
    43  	// The maximum error of the measured offset, in nanoseconds.
    44  	Uncertainty int64 `protobuf:"varint,2,opt,name=uncertainty" json:"uncertainty"`
    45  	// Measurement time, in nanoseconds from unix epoch.
    46  	MeasuredAt int64 `protobuf:"varint,3,opt,name=measured_at,json=measuredAt" json:"measured_at"`
    47  }
    48  
    49  func (m *RemoteOffset) Reset()      { *m = RemoteOffset{} }
    50  func (*RemoteOffset) ProtoMessage() {}
    51  func (*RemoteOffset) Descriptor() ([]byte, []int) {
    52  	return fileDescriptor_heartbeat_b9adbf29944dc273, []int{0}
    53  }
    54  func (m *RemoteOffset) XXX_Unmarshal(b []byte) error {
    55  	return m.Unmarshal(b)
    56  }
    57  func (m *RemoteOffset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    58  	b = b[:cap(b)]
    59  	n, err := m.MarshalTo(b)
    60  	if err != nil {
    61  		return nil, err
    62  	}
    63  	return b[:n], nil
    64  }
    65  func (dst *RemoteOffset) XXX_Merge(src proto.Message) {
    66  	xxx_messageInfo_RemoteOffset.Merge(dst, src)
    67  }
    68  func (m *RemoteOffset) XXX_Size() int {
    69  	return m.Size()
    70  }
    71  func (m *RemoteOffset) XXX_DiscardUnknown() {
    72  	xxx_messageInfo_RemoteOffset.DiscardUnknown(m)
    73  }
    74  
    75  var xxx_messageInfo_RemoteOffset proto.InternalMessageInfo
    76  
    77  // A PingRequest specifies the string to echo in response.
    78  // Fields are exported so that they will be serialized in the rpc call.
    79  type PingRequest struct {
    80  	// Echo this string with PingResponse.
    81  	Ping string `protobuf:"bytes,1,opt,name=ping" json:"ping"`
    82  	// The last offset the client measured with the server.
    83  	Offset RemoteOffset `protobuf:"bytes,2,opt,name=offset" json:"offset"`
    84  	// The address of the client.
    85  	Addr string `protobuf:"bytes,3,opt,name=addr" json:"addr"`
    86  	// The configured maximum clock offset (in nanoseconds) on the server.
    87  	MaxOffsetNanos int64 `protobuf:"varint,4,opt,name=max_offset_nanos,json=maxOffsetNanos" json:"max_offset_nanos"`
    88  	// Cluster ID to prevent connections between nodes in different clusters.
    89  	ClusterID     *github_com_cockroachdb_cockroach_pkg_util_uuid.UUID `protobuf:"bytes,5,opt,name=cluster_id,json=clusterId,customtype=github.com/cockroachdb/cockroach/pkg/util/uuid.UUID" json:"cluster_id,omitempty"`
    90  	ServerVersion roachpb.Version                                      `protobuf:"bytes,6,opt,name=server_version,json=serverVersion" json:"server_version"`
    91  	// Node ID to prevent connections from being misrouted to an invalid node inside the cluster.
    92  	NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID `protobuf:"varint,7,opt,name=node_id,json=nodeId,customtype=github.com/cockroachdb/cockroach/pkg/roachpb.NodeID" json:"node_id"`
    93  }
    94  
    95  func (m *PingRequest) Reset()         { *m = PingRequest{} }
    96  func (m *PingRequest) String() string { return proto.CompactTextString(m) }
    97  func (*PingRequest) ProtoMessage()    {}
    98  func (*PingRequest) Descriptor() ([]byte, []int) {
    99  	return fileDescriptor_heartbeat_b9adbf29944dc273, []int{1}
   100  }
   101  func (m *PingRequest) XXX_Unmarshal(b []byte) error {
   102  	return m.Unmarshal(b)
   103  }
   104  func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   105  	b = b[:cap(b)]
   106  	n, err := m.MarshalTo(b)
   107  	if err != nil {
   108  		return nil, err
   109  	}
   110  	return b[:n], nil
   111  }
   112  func (dst *PingRequest) XXX_Merge(src proto.Message) {
   113  	xxx_messageInfo_PingRequest.Merge(dst, src)
   114  }
   115  func (m *PingRequest) XXX_Size() int {
   116  	return m.Size()
   117  }
   118  func (m *PingRequest) XXX_DiscardUnknown() {
   119  	xxx_messageInfo_PingRequest.DiscardUnknown(m)
   120  }
   121  
   122  var xxx_messageInfo_PingRequest proto.InternalMessageInfo
   123  
   124  // A PingResponse contains the echoed ping request string.
   125  type PingResponse struct {
   126  	// An echo of value sent with PingRequest.
   127  	Pong          string          `protobuf:"bytes,1,opt,name=pong" json:"pong"`
   128  	ServerTime    int64           `protobuf:"varint,2,opt,name=server_time,json=serverTime" json:"server_time"`
   129  	ServerVersion roachpb.Version `protobuf:"bytes,3,opt,name=server_version,json=serverVersion" json:"server_version"`
   130  	// Cluster name to prevent joining a new node to the wrong cluster.
   131  	ClusterName string `protobuf:"bytes,4,opt,name=cluster_name,json=clusterName" json:"cluster_name"`
   132  	// Skip cluster name check if either side's name is empty / not configured.
   133  	DisableClusterNameVerification bool `protobuf:"varint,5,opt,name=disable_cluster_name_verification,json=disableClusterNameVerification" json:"disable_cluster_name_verification"`
   134  }
   135  
   136  func (m *PingResponse) Reset()         { *m = PingResponse{} }
   137  func (m *PingResponse) String() string { return proto.CompactTextString(m) }
   138  func (*PingResponse) ProtoMessage()    {}
   139  func (*PingResponse) Descriptor() ([]byte, []int) {
   140  	return fileDescriptor_heartbeat_b9adbf29944dc273, []int{2}
   141  }
   142  func (m *PingResponse) XXX_Unmarshal(b []byte) error {
   143  	return m.Unmarshal(b)
   144  }
   145  func (m *PingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   146  	b = b[:cap(b)]
   147  	n, err := m.MarshalTo(b)
   148  	if err != nil {
   149  		return nil, err
   150  	}
   151  	return b[:n], nil
   152  }
   153  func (dst *PingResponse) XXX_Merge(src proto.Message) {
   154  	xxx_messageInfo_PingResponse.Merge(dst, src)
   155  }
   156  func (m *PingResponse) XXX_Size() int {
   157  	return m.Size()
   158  }
   159  func (m *PingResponse) XXX_DiscardUnknown() {
   160  	xxx_messageInfo_PingResponse.DiscardUnknown(m)
   161  }
   162  
   163  var xxx_messageInfo_PingResponse proto.InternalMessageInfo
   164  
   165  func init() {
   166  	proto.RegisterType((*RemoteOffset)(nil), "cockroach.rpc.RemoteOffset")
   167  	proto.RegisterType((*PingRequest)(nil), "cockroach.rpc.PingRequest")
   168  	proto.RegisterType((*PingResponse)(nil), "cockroach.rpc.PingResponse")
   169  }
   170  
   171  // Reference imports to suppress errors if they are not otherwise used.
   172  var _ context.Context
   173  var _ grpc.ClientConn
   174  
   175  // This is a compile-time assertion to ensure that this generated file
   176  // is compatible with the grpc package it is being compiled against.
   177  const _ = grpc.SupportPackageIsVersion4
   178  
   179  // HeartbeatClient is the client API for Heartbeat service.
   180  //
   181  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
   182  type HeartbeatClient interface {
   183  	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
   184  }
   185  
   186  type heartbeatClient struct {
   187  	cc *grpc.ClientConn
   188  }
   189  
   190  func NewHeartbeatClient(cc *grpc.ClientConn) HeartbeatClient {
   191  	return &heartbeatClient{cc}
   192  }
   193  
   194  func (c *heartbeatClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
   195  	out := new(PingResponse)
   196  	err := c.cc.Invoke(ctx, "/cockroach.rpc.Heartbeat/Ping", in, out, opts...)
   197  	if err != nil {
   198  		return nil, err
   199  	}
   200  	return out, nil
   201  }
   202  
   203  // HeartbeatServer is the server API for Heartbeat service.
   204  type HeartbeatServer interface {
   205  	Ping(context.Context, *PingRequest) (*PingResponse, error)
   206  }
   207  
   208  func RegisterHeartbeatServer(s *grpc.Server, srv HeartbeatServer) {
   209  	s.RegisterService(&_Heartbeat_serviceDesc, srv)
   210  }
   211  
   212  func _Heartbeat_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   213  	in := new(PingRequest)
   214  	if err := dec(in); err != nil {
   215  		return nil, err
   216  	}
   217  	if interceptor == nil {
   218  		return srv.(HeartbeatServer).Ping(ctx, in)
   219  	}
   220  	info := &grpc.UnaryServerInfo{
   221  		Server:     srv,
   222  		FullMethod: "/cockroach.rpc.Heartbeat/Ping",
   223  	}
   224  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   225  		return srv.(HeartbeatServer).Ping(ctx, req.(*PingRequest))
   226  	}
   227  	return interceptor(ctx, in, info, handler)
   228  }
   229  
   230  var _Heartbeat_serviceDesc = grpc.ServiceDesc{
   231  	ServiceName: "cockroach.rpc.Heartbeat",
   232  	HandlerType: (*HeartbeatServer)(nil),
   233  	Methods: []grpc.MethodDesc{
   234  		{
   235  			MethodName: "Ping",
   236  			Handler:    _Heartbeat_Ping_Handler,
   237  		},
   238  	},
   239  	Streams:  []grpc.StreamDesc{},
   240  	Metadata: "rpc/heartbeat.proto",
   241  }
   242  
   243  // TestingHeartbeatStreamClient is the client API for TestingHeartbeatStream service.
   244  //
   245  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
   246  type TestingHeartbeatStreamClient interface {
   247  	PingStream(ctx context.Context, opts ...grpc.CallOption) (TestingHeartbeatStream_PingStreamClient, error)
   248  }
   249  
   250  type testingHeartbeatStreamClient struct {
   251  	cc *grpc.ClientConn
   252  }
   253  
   254  func NewTestingHeartbeatStreamClient(cc *grpc.ClientConn) TestingHeartbeatStreamClient {
   255  	return &testingHeartbeatStreamClient{cc}
   256  }
   257  
   258  func (c *testingHeartbeatStreamClient) PingStream(ctx context.Context, opts ...grpc.CallOption) (TestingHeartbeatStream_PingStreamClient, error) {
   259  	stream, err := c.cc.NewStream(ctx, &_TestingHeartbeatStream_serviceDesc.Streams[0], "/cockroach.rpc.TestingHeartbeatStream/PingStream", opts...)
   260  	if err != nil {
   261  		return nil, err
   262  	}
   263  	x := &testingHeartbeatStreamPingStreamClient{stream}
   264  	return x, nil
   265  }
   266  
   267  type TestingHeartbeatStream_PingStreamClient interface {
   268  	Send(*PingRequest) error
   269  	Recv() (*PingResponse, error)
   270  	grpc.ClientStream
   271  }
   272  
   273  type testingHeartbeatStreamPingStreamClient struct {
   274  	grpc.ClientStream
   275  }
   276  
   277  func (x *testingHeartbeatStreamPingStreamClient) Send(m *PingRequest) error {
   278  	return x.ClientStream.SendMsg(m)
   279  }
   280  
   281  func (x *testingHeartbeatStreamPingStreamClient) Recv() (*PingResponse, error) {
   282  	m := new(PingResponse)
   283  	if err := x.ClientStream.RecvMsg(m); err != nil {
   284  		return nil, err
   285  	}
   286  	return m, nil
   287  }
   288  
   289  // TestingHeartbeatStreamServer is the server API for TestingHeartbeatStream service.
   290  type TestingHeartbeatStreamServer interface {
   291  	PingStream(TestingHeartbeatStream_PingStreamServer) error
   292  }
   293  
   294  func RegisterTestingHeartbeatStreamServer(s *grpc.Server, srv TestingHeartbeatStreamServer) {
   295  	s.RegisterService(&_TestingHeartbeatStream_serviceDesc, srv)
   296  }
   297  
   298  func _TestingHeartbeatStream_PingStream_Handler(srv interface{}, stream grpc.ServerStream) error {
   299  	return srv.(TestingHeartbeatStreamServer).PingStream(&testingHeartbeatStreamPingStreamServer{stream})
   300  }
   301  
   302  type TestingHeartbeatStream_PingStreamServer interface {
   303  	Send(*PingResponse) error
   304  	Recv() (*PingRequest, error)
   305  	grpc.ServerStream
   306  }
   307  
   308  type testingHeartbeatStreamPingStreamServer struct {
   309  	grpc.ServerStream
   310  }
   311  
   312  func (x *testingHeartbeatStreamPingStreamServer) Send(m *PingResponse) error {
   313  	return x.ServerStream.SendMsg(m)
   314  }
   315  
   316  func (x *testingHeartbeatStreamPingStreamServer) Recv() (*PingRequest, error) {
   317  	m := new(PingRequest)
   318  	if err := x.ServerStream.RecvMsg(m); err != nil {
   319  		return nil, err
   320  	}
   321  	return m, nil
   322  }
   323  
   324  var _TestingHeartbeatStream_serviceDesc = grpc.ServiceDesc{
   325  	ServiceName: "cockroach.rpc.TestingHeartbeatStream",
   326  	HandlerType: (*TestingHeartbeatStreamServer)(nil),
   327  	Methods:     []grpc.MethodDesc{},
   328  	Streams: []grpc.StreamDesc{
   329  		{
   330  			StreamName:    "PingStream",
   331  			Handler:       _TestingHeartbeatStream_PingStream_Handler,
   332  			ServerStreams: true,
   333  			ClientStreams: true,
   334  		},
   335  	},
   336  	Metadata: "rpc/heartbeat.proto",
   337  }
   338  
   339  func (m *RemoteOffset) Marshal() (dAtA []byte, err error) {
   340  	size := m.Size()
   341  	dAtA = make([]byte, size)
   342  	n, err := m.MarshalTo(dAtA)
   343  	if err != nil {
   344  		return nil, err
   345  	}
   346  	return dAtA[:n], nil
   347  }
   348  
   349  func (m *RemoteOffset) MarshalTo(dAtA []byte) (int, error) {
   350  	var i int
   351  	_ = i
   352  	var l int
   353  	_ = l
   354  	dAtA[i] = 0x8
   355  	i++
   356  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.Offset))
   357  	dAtA[i] = 0x10
   358  	i++
   359  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.Uncertainty))
   360  	dAtA[i] = 0x18
   361  	i++
   362  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.MeasuredAt))
   363  	return i, nil
   364  }
   365  
   366  func (m *PingRequest) Marshal() (dAtA []byte, err error) {
   367  	size := m.Size()
   368  	dAtA = make([]byte, size)
   369  	n, err := m.MarshalTo(dAtA)
   370  	if err != nil {
   371  		return nil, err
   372  	}
   373  	return dAtA[:n], nil
   374  }
   375  
   376  func (m *PingRequest) MarshalTo(dAtA []byte) (int, error) {
   377  	var i int
   378  	_ = i
   379  	var l int
   380  	_ = l
   381  	dAtA[i] = 0xa
   382  	i++
   383  	i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Ping)))
   384  	i += copy(dAtA[i:], m.Ping)
   385  	dAtA[i] = 0x12
   386  	i++
   387  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.Offset.Size()))
   388  	n1, err := m.Offset.MarshalTo(dAtA[i:])
   389  	if err != nil {
   390  		return 0, err
   391  	}
   392  	i += n1
   393  	dAtA[i] = 0x1a
   394  	i++
   395  	i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Addr)))
   396  	i += copy(dAtA[i:], m.Addr)
   397  	dAtA[i] = 0x20
   398  	i++
   399  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.MaxOffsetNanos))
   400  	if m.ClusterID != nil {
   401  		dAtA[i] = 0x2a
   402  		i++
   403  		i = encodeVarintHeartbeat(dAtA, i, uint64(m.ClusterID.Size()))
   404  		n2, err := m.ClusterID.MarshalTo(dAtA[i:])
   405  		if err != nil {
   406  			return 0, err
   407  		}
   408  		i += n2
   409  	}
   410  	dAtA[i] = 0x32
   411  	i++
   412  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.ServerVersion.Size()))
   413  	n3, err := m.ServerVersion.MarshalTo(dAtA[i:])
   414  	if err != nil {
   415  		return 0, err
   416  	}
   417  	i += n3
   418  	dAtA[i] = 0x38
   419  	i++
   420  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.NodeID))
   421  	return i, nil
   422  }
   423  
   424  func (m *PingResponse) Marshal() (dAtA []byte, err error) {
   425  	size := m.Size()
   426  	dAtA = make([]byte, size)
   427  	n, err := m.MarshalTo(dAtA)
   428  	if err != nil {
   429  		return nil, err
   430  	}
   431  	return dAtA[:n], nil
   432  }
   433  
   434  func (m *PingResponse) MarshalTo(dAtA []byte) (int, error) {
   435  	var i int
   436  	_ = i
   437  	var l int
   438  	_ = l
   439  	dAtA[i] = 0xa
   440  	i++
   441  	i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.Pong)))
   442  	i += copy(dAtA[i:], m.Pong)
   443  	dAtA[i] = 0x10
   444  	i++
   445  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.ServerTime))
   446  	dAtA[i] = 0x1a
   447  	i++
   448  	i = encodeVarintHeartbeat(dAtA, i, uint64(m.ServerVersion.Size()))
   449  	n4, err := m.ServerVersion.MarshalTo(dAtA[i:])
   450  	if err != nil {
   451  		return 0, err
   452  	}
   453  	i += n4
   454  	dAtA[i] = 0x22
   455  	i++
   456  	i = encodeVarintHeartbeat(dAtA, i, uint64(len(m.ClusterName)))
   457  	i += copy(dAtA[i:], m.ClusterName)
   458  	dAtA[i] = 0x28
   459  	i++
   460  	if m.DisableClusterNameVerification {
   461  		dAtA[i] = 1
   462  	} else {
   463  		dAtA[i] = 0
   464  	}
   465  	i++
   466  	return i, nil
   467  }
   468  
   469  func encodeVarintHeartbeat(dAtA []byte, offset int, v uint64) int {
   470  	for v >= 1<<7 {
   471  		dAtA[offset] = uint8(v&0x7f | 0x80)
   472  		v >>= 7
   473  		offset++
   474  	}
   475  	dAtA[offset] = uint8(v)
   476  	return offset + 1
   477  }
   478  func (m *RemoteOffset) Size() (n int) {
   479  	if m == nil {
   480  		return 0
   481  	}
   482  	var l int
   483  	_ = l
   484  	n += 1 + sovHeartbeat(uint64(m.Offset))
   485  	n += 1 + sovHeartbeat(uint64(m.Uncertainty))
   486  	n += 1 + sovHeartbeat(uint64(m.MeasuredAt))
   487  	return n
   488  }
   489  
   490  func (m *PingRequest) Size() (n int) {
   491  	if m == nil {
   492  		return 0
   493  	}
   494  	var l int
   495  	_ = l
   496  	l = len(m.Ping)
   497  	n += 1 + l + sovHeartbeat(uint64(l))
   498  	l = m.Offset.Size()
   499  	n += 1 + l + sovHeartbeat(uint64(l))
   500  	l = len(m.Addr)
   501  	n += 1 + l + sovHeartbeat(uint64(l))
   502  	n += 1 + sovHeartbeat(uint64(m.MaxOffsetNanos))
   503  	if m.ClusterID != nil {
   504  		l = m.ClusterID.Size()
   505  		n += 1 + l + sovHeartbeat(uint64(l))
   506  	}
   507  	l = m.ServerVersion.Size()
   508  	n += 1 + l + sovHeartbeat(uint64(l))
   509  	n += 1 + sovHeartbeat(uint64(m.NodeID))
   510  	return n
   511  }
   512  
   513  func (m *PingResponse) Size() (n int) {
   514  	if m == nil {
   515  		return 0
   516  	}
   517  	var l int
   518  	_ = l
   519  	l = len(m.Pong)
   520  	n += 1 + l + sovHeartbeat(uint64(l))
   521  	n += 1 + sovHeartbeat(uint64(m.ServerTime))
   522  	l = m.ServerVersion.Size()
   523  	n += 1 + l + sovHeartbeat(uint64(l))
   524  	l = len(m.ClusterName)
   525  	n += 1 + l + sovHeartbeat(uint64(l))
   526  	n += 2
   527  	return n
   528  }
   529  
   530  func sovHeartbeat(x uint64) (n int) {
   531  	for {
   532  		n++
   533  		x >>= 7
   534  		if x == 0 {
   535  			break
   536  		}
   537  	}
   538  	return n
   539  }
   540  func sozHeartbeat(x uint64) (n int) {
   541  	return sovHeartbeat(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   542  }
   543  func (m *RemoteOffset) Unmarshal(dAtA []byte) error {
   544  	l := len(dAtA)
   545  	iNdEx := 0
   546  	for iNdEx < l {
   547  		preIndex := iNdEx
   548  		var wire uint64
   549  		for shift := uint(0); ; shift += 7 {
   550  			if shift >= 64 {
   551  				return ErrIntOverflowHeartbeat
   552  			}
   553  			if iNdEx >= l {
   554  				return io.ErrUnexpectedEOF
   555  			}
   556  			b := dAtA[iNdEx]
   557  			iNdEx++
   558  			wire |= (uint64(b) & 0x7F) << shift
   559  			if b < 0x80 {
   560  				break
   561  			}
   562  		}
   563  		fieldNum := int32(wire >> 3)
   564  		wireType := int(wire & 0x7)
   565  		if wireType == 4 {
   566  			return fmt.Errorf("proto: RemoteOffset: wiretype end group for non-group")
   567  		}
   568  		if fieldNum <= 0 {
   569  			return fmt.Errorf("proto: RemoteOffset: illegal tag %d (wire type %d)", fieldNum, wire)
   570  		}
   571  		switch fieldNum {
   572  		case 1:
   573  			if wireType != 0 {
   574  				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
   575  			}
   576  			m.Offset = 0
   577  			for shift := uint(0); ; shift += 7 {
   578  				if shift >= 64 {
   579  					return ErrIntOverflowHeartbeat
   580  				}
   581  				if iNdEx >= l {
   582  					return io.ErrUnexpectedEOF
   583  				}
   584  				b := dAtA[iNdEx]
   585  				iNdEx++
   586  				m.Offset |= (int64(b) & 0x7F) << shift
   587  				if b < 0x80 {
   588  					break
   589  				}
   590  			}
   591  		case 2:
   592  			if wireType != 0 {
   593  				return fmt.Errorf("proto: wrong wireType = %d for field Uncertainty", wireType)
   594  			}
   595  			m.Uncertainty = 0
   596  			for shift := uint(0); ; shift += 7 {
   597  				if shift >= 64 {
   598  					return ErrIntOverflowHeartbeat
   599  				}
   600  				if iNdEx >= l {
   601  					return io.ErrUnexpectedEOF
   602  				}
   603  				b := dAtA[iNdEx]
   604  				iNdEx++
   605  				m.Uncertainty |= (int64(b) & 0x7F) << shift
   606  				if b < 0x80 {
   607  					break
   608  				}
   609  			}
   610  		case 3:
   611  			if wireType != 0 {
   612  				return fmt.Errorf("proto: wrong wireType = %d for field MeasuredAt", wireType)
   613  			}
   614  			m.MeasuredAt = 0
   615  			for shift := uint(0); ; shift += 7 {
   616  				if shift >= 64 {
   617  					return ErrIntOverflowHeartbeat
   618  				}
   619  				if iNdEx >= l {
   620  					return io.ErrUnexpectedEOF
   621  				}
   622  				b := dAtA[iNdEx]
   623  				iNdEx++
   624  				m.MeasuredAt |= (int64(b) & 0x7F) << shift
   625  				if b < 0x80 {
   626  					break
   627  				}
   628  			}
   629  		default:
   630  			iNdEx = preIndex
   631  			skippy, err := skipHeartbeat(dAtA[iNdEx:])
   632  			if err != nil {
   633  				return err
   634  			}
   635  			if skippy < 0 {
   636  				return ErrInvalidLengthHeartbeat
   637  			}
   638  			if (iNdEx + skippy) > l {
   639  				return io.ErrUnexpectedEOF
   640  			}
   641  			iNdEx += skippy
   642  		}
   643  	}
   644  
   645  	if iNdEx > l {
   646  		return io.ErrUnexpectedEOF
   647  	}
   648  	return nil
   649  }
   650  func (m *PingRequest) Unmarshal(dAtA []byte) error {
   651  	l := len(dAtA)
   652  	iNdEx := 0
   653  	for iNdEx < l {
   654  		preIndex := iNdEx
   655  		var wire uint64
   656  		for shift := uint(0); ; shift += 7 {
   657  			if shift >= 64 {
   658  				return ErrIntOverflowHeartbeat
   659  			}
   660  			if iNdEx >= l {
   661  				return io.ErrUnexpectedEOF
   662  			}
   663  			b := dAtA[iNdEx]
   664  			iNdEx++
   665  			wire |= (uint64(b) & 0x7F) << shift
   666  			if b < 0x80 {
   667  				break
   668  			}
   669  		}
   670  		fieldNum := int32(wire >> 3)
   671  		wireType := int(wire & 0x7)
   672  		if wireType == 4 {
   673  			return fmt.Errorf("proto: PingRequest: wiretype end group for non-group")
   674  		}
   675  		if fieldNum <= 0 {
   676  			return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
   677  		}
   678  		switch fieldNum {
   679  		case 1:
   680  			if wireType != 2 {
   681  				return fmt.Errorf("proto: wrong wireType = %d for field Ping", wireType)
   682  			}
   683  			var stringLen uint64
   684  			for shift := uint(0); ; shift += 7 {
   685  				if shift >= 64 {
   686  					return ErrIntOverflowHeartbeat
   687  				}
   688  				if iNdEx >= l {
   689  					return io.ErrUnexpectedEOF
   690  				}
   691  				b := dAtA[iNdEx]
   692  				iNdEx++
   693  				stringLen |= (uint64(b) & 0x7F) << shift
   694  				if b < 0x80 {
   695  					break
   696  				}
   697  			}
   698  			intStringLen := int(stringLen)
   699  			if intStringLen < 0 {
   700  				return ErrInvalidLengthHeartbeat
   701  			}
   702  			postIndex := iNdEx + intStringLen
   703  			if postIndex > l {
   704  				return io.ErrUnexpectedEOF
   705  			}
   706  			m.Ping = string(dAtA[iNdEx:postIndex])
   707  			iNdEx = postIndex
   708  		case 2:
   709  			if wireType != 2 {
   710  				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
   711  			}
   712  			var msglen int
   713  			for shift := uint(0); ; shift += 7 {
   714  				if shift >= 64 {
   715  					return ErrIntOverflowHeartbeat
   716  				}
   717  				if iNdEx >= l {
   718  					return io.ErrUnexpectedEOF
   719  				}
   720  				b := dAtA[iNdEx]
   721  				iNdEx++
   722  				msglen |= (int(b) & 0x7F) << shift
   723  				if b < 0x80 {
   724  					break
   725  				}
   726  			}
   727  			if msglen < 0 {
   728  				return ErrInvalidLengthHeartbeat
   729  			}
   730  			postIndex := iNdEx + msglen
   731  			if postIndex > l {
   732  				return io.ErrUnexpectedEOF
   733  			}
   734  			if err := m.Offset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   735  				return err
   736  			}
   737  			iNdEx = postIndex
   738  		case 3:
   739  			if wireType != 2 {
   740  				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
   741  			}
   742  			var stringLen uint64
   743  			for shift := uint(0); ; shift += 7 {
   744  				if shift >= 64 {
   745  					return ErrIntOverflowHeartbeat
   746  				}
   747  				if iNdEx >= l {
   748  					return io.ErrUnexpectedEOF
   749  				}
   750  				b := dAtA[iNdEx]
   751  				iNdEx++
   752  				stringLen |= (uint64(b) & 0x7F) << shift
   753  				if b < 0x80 {
   754  					break
   755  				}
   756  			}
   757  			intStringLen := int(stringLen)
   758  			if intStringLen < 0 {
   759  				return ErrInvalidLengthHeartbeat
   760  			}
   761  			postIndex := iNdEx + intStringLen
   762  			if postIndex > l {
   763  				return io.ErrUnexpectedEOF
   764  			}
   765  			m.Addr = string(dAtA[iNdEx:postIndex])
   766  			iNdEx = postIndex
   767  		case 4:
   768  			if wireType != 0 {
   769  				return fmt.Errorf("proto: wrong wireType = %d for field MaxOffsetNanos", wireType)
   770  			}
   771  			m.MaxOffsetNanos = 0
   772  			for shift := uint(0); ; shift += 7 {
   773  				if shift >= 64 {
   774  					return ErrIntOverflowHeartbeat
   775  				}
   776  				if iNdEx >= l {
   777  					return io.ErrUnexpectedEOF
   778  				}
   779  				b := dAtA[iNdEx]
   780  				iNdEx++
   781  				m.MaxOffsetNanos |= (int64(b) & 0x7F) << shift
   782  				if b < 0x80 {
   783  					break
   784  				}
   785  			}
   786  		case 5:
   787  			if wireType != 2 {
   788  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
   789  			}
   790  			var byteLen int
   791  			for shift := uint(0); ; shift += 7 {
   792  				if shift >= 64 {
   793  					return ErrIntOverflowHeartbeat
   794  				}
   795  				if iNdEx >= l {
   796  					return io.ErrUnexpectedEOF
   797  				}
   798  				b := dAtA[iNdEx]
   799  				iNdEx++
   800  				byteLen |= (int(b) & 0x7F) << shift
   801  				if b < 0x80 {
   802  					break
   803  				}
   804  			}
   805  			if byteLen < 0 {
   806  				return ErrInvalidLengthHeartbeat
   807  			}
   808  			postIndex := iNdEx + byteLen
   809  			if postIndex > l {
   810  				return io.ErrUnexpectedEOF
   811  			}
   812  			var v github_com_cockroachdb_cockroach_pkg_util_uuid.UUID
   813  			m.ClusterID = &v
   814  			if err := m.ClusterID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   815  				return err
   816  			}
   817  			iNdEx = postIndex
   818  		case 6:
   819  			if wireType != 2 {
   820  				return fmt.Errorf("proto: wrong wireType = %d for field ServerVersion", wireType)
   821  			}
   822  			var msglen int
   823  			for shift := uint(0); ; shift += 7 {
   824  				if shift >= 64 {
   825  					return ErrIntOverflowHeartbeat
   826  				}
   827  				if iNdEx >= l {
   828  					return io.ErrUnexpectedEOF
   829  				}
   830  				b := dAtA[iNdEx]
   831  				iNdEx++
   832  				msglen |= (int(b) & 0x7F) << shift
   833  				if b < 0x80 {
   834  					break
   835  				}
   836  			}
   837  			if msglen < 0 {
   838  				return ErrInvalidLengthHeartbeat
   839  			}
   840  			postIndex := iNdEx + msglen
   841  			if postIndex > l {
   842  				return io.ErrUnexpectedEOF
   843  			}
   844  			if err := m.ServerVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   845  				return err
   846  			}
   847  			iNdEx = postIndex
   848  		case 7:
   849  			if wireType != 0 {
   850  				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
   851  			}
   852  			m.NodeID = 0
   853  			for shift := uint(0); ; shift += 7 {
   854  				if shift >= 64 {
   855  					return ErrIntOverflowHeartbeat
   856  				}
   857  				if iNdEx >= l {
   858  					return io.ErrUnexpectedEOF
   859  				}
   860  				b := dAtA[iNdEx]
   861  				iNdEx++
   862  				m.NodeID |= (github_com_cockroachdb_cockroach_pkg_roachpb.NodeID(b) & 0x7F) << shift
   863  				if b < 0x80 {
   864  					break
   865  				}
   866  			}
   867  		default:
   868  			iNdEx = preIndex
   869  			skippy, err := skipHeartbeat(dAtA[iNdEx:])
   870  			if err != nil {
   871  				return err
   872  			}
   873  			if skippy < 0 {
   874  				return ErrInvalidLengthHeartbeat
   875  			}
   876  			if (iNdEx + skippy) > l {
   877  				return io.ErrUnexpectedEOF
   878  			}
   879  			iNdEx += skippy
   880  		}
   881  	}
   882  
   883  	if iNdEx > l {
   884  		return io.ErrUnexpectedEOF
   885  	}
   886  	return nil
   887  }
   888  func (m *PingResponse) Unmarshal(dAtA []byte) error {
   889  	l := len(dAtA)
   890  	iNdEx := 0
   891  	for iNdEx < l {
   892  		preIndex := iNdEx
   893  		var wire uint64
   894  		for shift := uint(0); ; shift += 7 {
   895  			if shift >= 64 {
   896  				return ErrIntOverflowHeartbeat
   897  			}
   898  			if iNdEx >= l {
   899  				return io.ErrUnexpectedEOF
   900  			}
   901  			b := dAtA[iNdEx]
   902  			iNdEx++
   903  			wire |= (uint64(b) & 0x7F) << shift
   904  			if b < 0x80 {
   905  				break
   906  			}
   907  		}
   908  		fieldNum := int32(wire >> 3)
   909  		wireType := int(wire & 0x7)
   910  		if wireType == 4 {
   911  			return fmt.Errorf("proto: PingResponse: wiretype end group for non-group")
   912  		}
   913  		if fieldNum <= 0 {
   914  			return fmt.Errorf("proto: PingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
   915  		}
   916  		switch fieldNum {
   917  		case 1:
   918  			if wireType != 2 {
   919  				return fmt.Errorf("proto: wrong wireType = %d for field Pong", wireType)
   920  			}
   921  			var stringLen uint64
   922  			for shift := uint(0); ; shift += 7 {
   923  				if shift >= 64 {
   924  					return ErrIntOverflowHeartbeat
   925  				}
   926  				if iNdEx >= l {
   927  					return io.ErrUnexpectedEOF
   928  				}
   929  				b := dAtA[iNdEx]
   930  				iNdEx++
   931  				stringLen |= (uint64(b) & 0x7F) << shift
   932  				if b < 0x80 {
   933  					break
   934  				}
   935  			}
   936  			intStringLen := int(stringLen)
   937  			if intStringLen < 0 {
   938  				return ErrInvalidLengthHeartbeat
   939  			}
   940  			postIndex := iNdEx + intStringLen
   941  			if postIndex > l {
   942  				return io.ErrUnexpectedEOF
   943  			}
   944  			m.Pong = string(dAtA[iNdEx:postIndex])
   945  			iNdEx = postIndex
   946  		case 2:
   947  			if wireType != 0 {
   948  				return fmt.Errorf("proto: wrong wireType = %d for field ServerTime", wireType)
   949  			}
   950  			m.ServerTime = 0
   951  			for shift := uint(0); ; shift += 7 {
   952  				if shift >= 64 {
   953  					return ErrIntOverflowHeartbeat
   954  				}
   955  				if iNdEx >= l {
   956  					return io.ErrUnexpectedEOF
   957  				}
   958  				b := dAtA[iNdEx]
   959  				iNdEx++
   960  				m.ServerTime |= (int64(b) & 0x7F) << shift
   961  				if b < 0x80 {
   962  					break
   963  				}
   964  			}
   965  		case 3:
   966  			if wireType != 2 {
   967  				return fmt.Errorf("proto: wrong wireType = %d for field ServerVersion", wireType)
   968  			}
   969  			var msglen int
   970  			for shift := uint(0); ; shift += 7 {
   971  				if shift >= 64 {
   972  					return ErrIntOverflowHeartbeat
   973  				}
   974  				if iNdEx >= l {
   975  					return io.ErrUnexpectedEOF
   976  				}
   977  				b := dAtA[iNdEx]
   978  				iNdEx++
   979  				msglen |= (int(b) & 0x7F) << shift
   980  				if b < 0x80 {
   981  					break
   982  				}
   983  			}
   984  			if msglen < 0 {
   985  				return ErrInvalidLengthHeartbeat
   986  			}
   987  			postIndex := iNdEx + msglen
   988  			if postIndex > l {
   989  				return io.ErrUnexpectedEOF
   990  			}
   991  			if err := m.ServerVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   992  				return err
   993  			}
   994  			iNdEx = postIndex
   995  		case 4:
   996  			if wireType != 2 {
   997  				return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
   998  			}
   999  			var stringLen uint64
  1000  			for shift := uint(0); ; shift += 7 {
  1001  				if shift >= 64 {
  1002  					return ErrIntOverflowHeartbeat
  1003  				}
  1004  				if iNdEx >= l {
  1005  					return io.ErrUnexpectedEOF
  1006  				}
  1007  				b := dAtA[iNdEx]
  1008  				iNdEx++
  1009  				stringLen |= (uint64(b) & 0x7F) << shift
  1010  				if b < 0x80 {
  1011  					break
  1012  				}
  1013  			}
  1014  			intStringLen := int(stringLen)
  1015  			if intStringLen < 0 {
  1016  				return ErrInvalidLengthHeartbeat
  1017  			}
  1018  			postIndex := iNdEx + intStringLen
  1019  			if postIndex > l {
  1020  				return io.ErrUnexpectedEOF
  1021  			}
  1022  			m.ClusterName = string(dAtA[iNdEx:postIndex])
  1023  			iNdEx = postIndex
  1024  		case 5:
  1025  			if wireType != 0 {
  1026  				return fmt.Errorf("proto: wrong wireType = %d for field DisableClusterNameVerification", wireType)
  1027  			}
  1028  			var v int
  1029  			for shift := uint(0); ; shift += 7 {
  1030  				if shift >= 64 {
  1031  					return ErrIntOverflowHeartbeat
  1032  				}
  1033  				if iNdEx >= l {
  1034  					return io.ErrUnexpectedEOF
  1035  				}
  1036  				b := dAtA[iNdEx]
  1037  				iNdEx++
  1038  				v |= (int(b) & 0x7F) << shift
  1039  				if b < 0x80 {
  1040  					break
  1041  				}
  1042  			}
  1043  			m.DisableClusterNameVerification = bool(v != 0)
  1044  		default:
  1045  			iNdEx = preIndex
  1046  			skippy, err := skipHeartbeat(dAtA[iNdEx:])
  1047  			if err != nil {
  1048  				return err
  1049  			}
  1050  			if skippy < 0 {
  1051  				return ErrInvalidLengthHeartbeat
  1052  			}
  1053  			if (iNdEx + skippy) > l {
  1054  				return io.ErrUnexpectedEOF
  1055  			}
  1056  			iNdEx += skippy
  1057  		}
  1058  	}
  1059  
  1060  	if iNdEx > l {
  1061  		return io.ErrUnexpectedEOF
  1062  	}
  1063  	return nil
  1064  }
  1065  func skipHeartbeat(dAtA []byte) (n int, err error) {
  1066  	l := len(dAtA)
  1067  	iNdEx := 0
  1068  	for iNdEx < l {
  1069  		var wire uint64
  1070  		for shift := uint(0); ; shift += 7 {
  1071  			if shift >= 64 {
  1072  				return 0, ErrIntOverflowHeartbeat
  1073  			}
  1074  			if iNdEx >= l {
  1075  				return 0, io.ErrUnexpectedEOF
  1076  			}
  1077  			b := dAtA[iNdEx]
  1078  			iNdEx++
  1079  			wire |= (uint64(b) & 0x7F) << shift
  1080  			if b < 0x80 {
  1081  				break
  1082  			}
  1083  		}
  1084  		wireType := int(wire & 0x7)
  1085  		switch wireType {
  1086  		case 0:
  1087  			for shift := uint(0); ; shift += 7 {
  1088  				if shift >= 64 {
  1089  					return 0, ErrIntOverflowHeartbeat
  1090  				}
  1091  				if iNdEx >= l {
  1092  					return 0, io.ErrUnexpectedEOF
  1093  				}
  1094  				iNdEx++
  1095  				if dAtA[iNdEx-1] < 0x80 {
  1096  					break
  1097  				}
  1098  			}
  1099  			return iNdEx, nil
  1100  		case 1:
  1101  			iNdEx += 8
  1102  			return iNdEx, nil
  1103  		case 2:
  1104  			var length int
  1105  			for shift := uint(0); ; shift += 7 {
  1106  				if shift >= 64 {
  1107  					return 0, ErrIntOverflowHeartbeat
  1108  				}
  1109  				if iNdEx >= l {
  1110  					return 0, io.ErrUnexpectedEOF
  1111  				}
  1112  				b := dAtA[iNdEx]
  1113  				iNdEx++
  1114  				length |= (int(b) & 0x7F) << shift
  1115  				if b < 0x80 {
  1116  					break
  1117  				}
  1118  			}
  1119  			iNdEx += length
  1120  			if length < 0 {
  1121  				return 0, ErrInvalidLengthHeartbeat
  1122  			}
  1123  			return iNdEx, nil
  1124  		case 3:
  1125  			for {
  1126  				var innerWire uint64
  1127  				var start int = iNdEx
  1128  				for shift := uint(0); ; shift += 7 {
  1129  					if shift >= 64 {
  1130  						return 0, ErrIntOverflowHeartbeat
  1131  					}
  1132  					if iNdEx >= l {
  1133  						return 0, io.ErrUnexpectedEOF
  1134  					}
  1135  					b := dAtA[iNdEx]
  1136  					iNdEx++
  1137  					innerWire |= (uint64(b) & 0x7F) << shift
  1138  					if b < 0x80 {
  1139  						break
  1140  					}
  1141  				}
  1142  				innerWireType := int(innerWire & 0x7)
  1143  				if innerWireType == 4 {
  1144  					break
  1145  				}
  1146  				next, err := skipHeartbeat(dAtA[start:])
  1147  				if err != nil {
  1148  					return 0, err
  1149  				}
  1150  				iNdEx = start + next
  1151  			}
  1152  			return iNdEx, nil
  1153  		case 4:
  1154  			return iNdEx, nil
  1155  		case 5:
  1156  			iNdEx += 4
  1157  			return iNdEx, nil
  1158  		default:
  1159  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1160  		}
  1161  	}
  1162  	panic("unreachable")
  1163  }
  1164  
  1165  var (
  1166  	ErrInvalidLengthHeartbeat = fmt.Errorf("proto: negative length found during unmarshaling")
  1167  	ErrIntOverflowHeartbeat   = fmt.Errorf("proto: integer overflow")
  1168  )
  1169  
  1170  func init() { proto.RegisterFile("rpc/heartbeat.proto", fileDescriptor_heartbeat_b9adbf29944dc273) }
  1171  
  1172  var fileDescriptor_heartbeat_b9adbf29944dc273 = []byte{
  1173  	// 594 bytes of a gzipped FileDescriptorProto
  1174  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0x41, 0x4f, 0xd4, 0x40,
  1175  	0x14, 0x6e, 0xd9, 0xb2, 0xb8, 0xb3, 0x0b, 0x31, 0xa3, 0x21, 0xcd, 0x62, 0xba, 0xb8, 0x09, 0xba,
  1176  	0xa7, 0xd6, 0xe0, 0x49, 0x6f, 0x2c, 0x18, 0xdd, 0x98, 0x2c, 0x66, 0x05, 0x0e, 0x1e, 0x6c, 0x66,
  1177  	0x3b, 0x8f, 0x32, 0x81, 0xce, 0xd4, 0xe9, 0x94, 0xe0, 0xd1, 0x7f, 0x60, 0x3c, 0x79, 0xf4, 0x77,
  1178  	0xf8, 0x0b, 0x38, 0x72, 0x24, 0x1e, 0x88, 0x2e, 0x7f, 0xc4, 0x4c, 0xa7, 0xbb, 0x14, 0xe4, 0x60,
  1179  	0xb8, 0xbd, 0xbe, 0xf7, 0xbd, 0xf7, 0xbe, 0x6f, 0xbe, 0x57, 0xf4, 0x40, 0xa6, 0x51, 0x70, 0x00,
  1180  	0x44, 0xaa, 0x31, 0x10, 0xe5, 0xa7, 0x52, 0x28, 0x81, 0x17, 0x23, 0x11, 0x1d, 0x4a, 0x41, 0xa2,
  1181  	0x03, 0x5f, 0xa6, 0x51, 0x7b, 0xb9, 0x08, 0xd3, 0x71, 0x90, 0x80, 0x22, 0x94, 0x28, 0x62, 0x60,
  1182  	0xed, 0x87, 0xb1, 0x88, 0x45, 0x11, 0x06, 0x3a, 0x32, 0xd9, 0xee, 0x17, 0x1b, 0xb5, 0x46, 0x90,
  1183  	0x08, 0x05, 0xdb, 0xfb, 0xfb, 0x19, 0x28, 0xfc, 0x08, 0xd5, 0x45, 0x11, 0xb9, 0xf6, 0xaa, 0xdd,
  1184  	0xab, 0xf5, 0x9d, 0xd3, 0x8b, 0x8e, 0x35, 0x2a, 0x73, 0xf8, 0x09, 0x6a, 0xe6, 0x3c, 0x02, 0xa9,
  1185  	0x08, 0xe3, 0xea, 0xb3, 0x3b, 0x57, 0x81, 0x54, 0x0b, 0x78, 0x0d, 0x35, 0x13, 0x20, 0x59, 0x2e,
  1186  	0x81, 0x86, 0x44, 0xb9, 0xb5, 0x0a, 0x0e, 0x4d, 0x0b, 0x1b, 0xea, 0xa5, 0xf3, 0xfd, 0x47, 0xc7,
  1187  	0xea, 0xfe, 0xac, 0xa1, 0xe6, 0x3b, 0xc6, 0xe3, 0x11, 0x7c, 0xca, 0x21, 0x53, 0xd8, 0x45, 0x4e,
  1188  	0xca, 0x78, 0x5c, 0x10, 0x68, 0x94, 0x5d, 0x45, 0x06, 0xbf, 0x98, 0x91, 0xd3, 0x9b, 0x9b, 0xeb,
  1189  	0x2b, 0xfe, 0x35, 0xed, 0x7e, 0x55, 0xc9, 0x0d, 0xe6, 0x2e, 0x72, 0x08, 0xa5, 0xb2, 0xa0, 0x32,
  1190  	0x1b, 0xaa, 0x33, 0xd8, 0x47, 0xf7, 0x13, 0x72, 0x12, 0x1a, 0x5c, 0xc8, 0x09, 0x17, 0x99, 0xeb,
  1191  	0x54, 0x08, 0x2f, 0x25, 0xe4, 0xc4, 0x8c, 0x1c, 0xea, 0x1a, 0x8e, 0x10, 0x8a, 0x8e, 0xf2, 0x4c,
  1192  	0x81, 0x0c, 0x19, 0x75, 0xe7, 0x57, 0xed, 0x5e, 0xab, 0xbf, 0xf5, 0xeb, 0xa2, 0xf3, 0x3c, 0x66,
  1193  	0xea, 0x20, 0x1f, 0xfb, 0x91, 0x48, 0x82, 0x19, 0x2d, 0x3a, 0xbe, 0x8a, 0x83, 0xf4, 0x30, 0x0e,
  1194  	0x72, 0xc5, 0x8e, 0x82, 0x3c, 0x67, 0xd4, 0xdf, 0xdd, 0x1d, 0x6c, 0x4d, 0x2e, 0x3a, 0x8d, 0x4d,
  1195  	0x33, 0x6c, 0xb0, 0x35, 0x6a, 0x94, 0x73, 0x07, 0x14, 0xbf, 0x46, 0x4b, 0x19, 0xc8, 0x63, 0x90,
  1196  	0xe1, 0x31, 0xc8, 0x8c, 0x09, 0xee, 0xd6, 0x0b, 0xc5, 0xed, 0xaa, 0x62, 0x63, 0xb4, 0xbf, 0x67,
  1197  	0x10, 0x25, 0xdd, 0x45, 0xd3, 0x57, 0x26, 0xf1, 0x47, 0xb4, 0xc0, 0x05, 0x05, 0x4d, 0x75, 0x61,
  1198  	0xd5, 0xee, 0xcd, 0xf7, 0x5f, 0x69, 0xd4, 0x7f, 0xd3, 0x9d, 0xee, 0x18, 0x0a, 0x0a, 0x05, 0xdd,
  1199  	0xba, 0x89, 0x46, 0x75, 0x3d, 0x75, 0x40, 0xbb, 0xdf, 0xe6, 0x50, 0xcb, 0x98, 0x97, 0xa5, 0x82,
  1200  	0x67, 0x50, 0xb8, 0x27, 0xfe, 0x71, 0x4f, 0xf0, 0x58, 0x1f, 0x45, 0xa9, 0x49, 0xb1, 0x04, 0xae,
  1201  	0x1d, 0x0f, 0x32, 0x85, 0x1d, 0x96, 0xc0, 0x2d, 0xd2, 0x6b, 0x77, 0x93, 0xfe, 0x14, 0xb5, 0xa6,
  1202  	0x46, 0x71, 0x92, 0x40, 0x61, 0xea, 0x94, 0x51, 0xb3, 0xac, 0x0c, 0x49, 0x02, 0x78, 0x1b, 0x3d,
  1203  	0xa6, 0x2c, 0x23, 0xe3, 0x23, 0x08, 0xab, 0x0d, 0x7a, 0x3f, 0xdb, 0x67, 0x11, 0x51, 0x9a, 0x84,
  1204  	0x36, 0xfa, 0x5e, 0xd9, 0xed, 0x95, 0xf0, 0xcd, 0xab, 0x21, 0x7b, 0x15, 0xec, 0xfa, 0x10, 0x35,
  1205  	0xde, 0x4c, 0xff, 0x52, 0xbc, 0x81, 0x1c, 0xfd, 0x40, 0xb8, 0x7d, 0xe3, 0x58, 0x2b, 0x27, 0xdf,
  1206  	0x5e, 0xb9, 0xb5, 0x66, 0x5e, 0xb4, 0x6b, 0xad, 0x03, 0x5a, 0xde, 0x81, 0x4c, 0x31, 0x1e, 0xcf,
  1207  	0xc6, 0xbe, 0x57, 0x12, 0x48, 0x82, 0xdf, 0x22, 0xa4, 0xb1, 0xe5, 0xd7, 0xdd, 0x57, 0xf4, 0xec,
  1208  	0x67, 0x76, 0x7f, 0xed, 0xf4, 0x8f, 0x67, 0x9d, 0x4e, 0x3c, 0xfb, 0x6c, 0xe2, 0xd9, 0xe7, 0x13,
  1209  	0xcf, 0xfe, 0x3d, 0xf1, 0xec, 0xaf, 0x97, 0x9e, 0x75, 0x76, 0xe9, 0x59, 0xe7, 0x97, 0x9e, 0xf5,
  1210  	0xa1, 0x26, 0xd3, 0xe8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x08, 0x36, 0xe1, 0x9a, 0x86, 0x04,
  1211  	0x00, 0x00,
  1212  }