net.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: net.proto

package net_pb

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Log represents a thread log.
type Log struct {
	// ID of the log.
	ID *ProtoPeerID `protobuf:"bytes,1,opt,name=ID,proto3,customtype=ProtoPeerID" json:"ID,omitempty"`
	// pubKey of the log.
	PubKey *ProtoPubKey `protobuf:"bytes,2,opt,name=pubKey,proto3,customtype=ProtoPubKey" json:"pubKey,omitempty"`
	// addrs of the log.
	Addrs []ProtoAddr `protobuf:"bytes,3,rep,name=addrs,proto3,customtype=ProtoAddr" json:"addrs,omitempty"`
	// head of the log.
	Head *ProtoCid `protobuf:"bytes,4,opt,name=head,proto3,customtype=ProtoCid" json:"head,omitempty"`
	// position of the log
	Counter int64 `protobuf:"varint,5,opt,name=counter,proto3" json:"counter,omitempty"`
}

func (m *Log) Reset()         { *m = Log{} }
func (m *Log) String() string { return proto.CompactTextString(m) }
func (*Log) ProtoMessage()    {}
func (*Log) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{0}
}
func (m *Log) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Log) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Log.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Log) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Log.Merge(m, src)
}
func (m *Log) XXX_Size() int {
	return m.Size()
}
func (m *Log) XXX_DiscardUnknown() {
	xxx_messageInfo_Log.DiscardUnknown(m)
}

var xxx_messageInfo_Log proto.InternalMessageInfo

func (m *Log) GetCounter() int64 {
	if m != nil {
		return m.Counter
	}
	return 0
}

// Record is a thread record containing link data.
type Log_Record struct {
	// recordNode is the top-level node's raw data.
	RecordNode []byte `protobuf:"bytes,1,opt,name=recordNode,proto3" json:"recordNode,omitempty"`
	// eventNode is the event node's raw data.
	EventNode []byte `protobuf:"bytes,2,opt,name=eventNode,proto3" json:"eventNode,omitempty"`
	// headerNode is the header node's raw data.
	HeaderNode []byte `protobuf:"bytes,3,opt,name=headerNode,proto3" json:"headerNode,omitempty"`
	// bodyNode is the body node's raw data.
	BodyNode []byte `protobuf:"bytes,4,opt,name=bodyNode,proto3" json:"bodyNode,omitempty"`
}

func (m *Log_Record) Reset()         { *m = Log_Record{} }
func (m *Log_Record) String() string { return proto.CompactTextString(m) }
func (*Log_Record) ProtoMessage()    {}
func (*Log_Record) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{0, 0}
}
func (m *Log_Record) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Log_Record) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Log_Record.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Log_Record) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Log_Record.Merge(m, src)
}
func (m *Log_Record) XXX_Size() int {
	return m.Size()
}
func (m *Log_Record) XXX_DiscardUnknown() {
	xxx_messageInfo_Log_Record.DiscardUnknown(m)
}

var xxx_messageInfo_Log_Record proto.InternalMessageInfo

func (m *Log_Record) GetRecordNode() []byte {
	if m != nil {
		return m.RecordNode
	}
	return nil
}

func (m *Log_Record) GetEventNode() []byte {
	if m != nil {
		return m.EventNode
	}
	return nil
}

func (m *Log_Record) GetHeaderNode() []byte {
	if m != nil {
		return m.HeaderNode
	}
	return nil
}

func (m *Log_Record) GetBodyNode() []byte {
	if m != nil {
		return m.BodyNode
	}
	return nil
}

// GetLogsRequest is used to request thread logs.
type GetLogsRequest struct {
	// body is the message body.
	Body *GetLogsRequest_Body `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}

func (m *GetLogsRequest) Reset()         { *m = GetLogsRequest{} }
func (m *GetLogsRequest) String() string { return proto.CompactTextString(m) }
func (*GetLogsRequest) ProtoMessage()    {}
func (*GetLogsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{1}
}
func (m *GetLogsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLogsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLogsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLogsRequest.Merge(m, src)
}
func (m *GetLogsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetLogsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLogsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetLogsRequest proto.InternalMessageInfo

func (m *GetLogsRequest) GetBody() *GetLogsRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

type GetLogsRequest_Body struct {
	// threadID is the target thread's ID.
	ThreadID *ProtoThreadID `protobuf:"bytes,1,opt,name=threadID,proto3,customtype=ProtoThreadID" json:"threadID,omitempty"`
	// serviceKey for the thread.
	ServiceKey *ProtoKey `protobuf:"bytes,2,opt,name=serviceKey,proto3,customtype=ProtoKey" json:"serviceKey,omitempty"`
}

func (m *GetLogsRequest_Body) Reset()         { *m = GetLogsRequest_Body{} }
func (m *GetLogsRequest_Body) String() string { return proto.CompactTextString(m) }
func (*GetLogsRequest_Body) ProtoMessage()    {}
func (*GetLogsRequest_Body) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{1, 0}
}
func (m *GetLogsRequest_Body) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLogsRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLogsRequest_Body.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLogsRequest_Body) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLogsRequest_Body.Merge(m, src)
}
func (m *GetLogsRequest_Body) XXX_Size() int {
	return m.Size()
}
func (m *GetLogsRequest_Body) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLogsRequest_Body.DiscardUnknown(m)
}

var xxx_messageInfo_GetLogsRequest_Body proto.InternalMessageInfo

// GetLogsReply is the response from a GetLogsRequest.
type GetLogsReply struct {
	// logs are the result of the request.
	Logs []*Log `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"`
}

func (m *GetLogsReply) Reset()         { *m = GetLogsReply{} }
func (m *GetLogsReply) String() string { return proto.CompactTextString(m) }
func (*GetLogsReply) ProtoMessage()    {}
func (*GetLogsReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{2}
}
func (m *GetLogsReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLogsReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLogsReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetLogsReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLogsReply.Merge(m, src)
}
func (m *GetLogsReply) XXX_Size() int {
	return m.Size()
}
func (m *GetLogsReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLogsReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetLogsReply proto.InternalMessageInfo

func (m *GetLogsReply) GetLogs() []*Log {
	if m != nil {
		return m.Logs
	}
	return nil
}

// PushLogRequest is used to push a thread log to a peer.
type PushLogRequest struct {
	// body is the message body.
	Body *PushLogRequest_Body `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}

func (m *PushLogRequest) Reset()         { *m = PushLogRequest{} }
func (m *PushLogRequest) String() string { return proto.CompactTextString(m) }
func (*PushLogRequest) ProtoMessage()    {}
func (*PushLogRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{3}
}
func (m *PushLogRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushLogRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushLogRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushLogRequest.Merge(m, src)
}
func (m *PushLogRequest) XXX_Size() int {
	return m.Size()
}
func (m *PushLogRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PushLogRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PushLogRequest proto.InternalMessageInfo

func (m *PushLogRequest) GetBody() *PushLogRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

type PushLogRequest_Body struct {
	// threadID is the target thread's ID.
	ThreadID *ProtoThreadID `protobuf:"bytes,1,opt,name=threadID,proto3,customtype=ProtoThreadID" json:"threadID,omitempty"`
	// serviceKey for the thread.
	ServiceKey *ProtoKey `protobuf:"bytes,2,opt,name=serviceKey,proto3,customtype=ProtoKey" json:"serviceKey,omitempty"`
	// readKey for the thread.
	ReadKey *ProtoKey `protobuf:"bytes,3,opt,name=readKey,proto3,customtype=ProtoKey" json:"readKey,omitempty"`
	// log is the actual log payload.
	Log *Log `protobuf:"bytes,4,opt,name=log,proto3" json:"log,omitempty"`
}

func (m *PushLogRequest_Body) Reset()         { *m = PushLogRequest_Body{} }
func (m *PushLogRequest_Body) String() string { return proto.CompactTextString(m) }
func (*PushLogRequest_Body) ProtoMessage()    {}
func (*PushLogRequest_Body) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{3, 0}
}
func (m *PushLogRequest_Body) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushLogRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushLogRequest_Body.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushLogRequest_Body) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushLogRequest_Body.Merge(m, src)
}
func (m *PushLogRequest_Body) XXX_Size() int {
	return m.Size()
}
func (m *PushLogRequest_Body) XXX_DiscardUnknown() {
	xxx_messageInfo_PushLogRequest_Body.DiscardUnknown(m)
}

var xxx_messageInfo_PushLogRequest_Body proto.InternalMessageInfo

func (m *PushLogRequest_Body) GetLog() *Log {
	if m != nil {
		return m.Log
	}
	return nil
}

// PushLogReply is the response from a PushLogRequest.
type PushLogReply struct {
}

func (m *PushLogReply) Reset()         { *m = PushLogReply{} }
func (m *PushLogReply) String() string { return proto.CompactTextString(m) }
func (*PushLogReply) ProtoMessage()    {}
func (*PushLogReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{4}
}
func (m *PushLogReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushLogReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushLogReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushLogReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushLogReply.Merge(m, src)
}
func (m *PushLogReply) XXX_Size() int {
	return m.Size()
}
func (m *PushLogReply) XXX_DiscardUnknown() {
	xxx_messageInfo_PushLogReply.DiscardUnknown(m)
}

var xxx_messageInfo_PushLogReply proto.InternalMessageInfo

// GetRecordsRequest is used to request records from a log address.
type GetRecordsRequest struct {
	// body is the message body.
	Body *GetRecordsRequest_Body `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}

func (m *GetRecordsRequest) Reset()         { *m = GetRecordsRequest{} }
func (m *GetRecordsRequest) String() string { return proto.CompactTextString(m) }
func (*GetRecordsRequest) ProtoMessage()    {}
func (*GetRecordsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{5}
}
func (m *GetRecordsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetRecordsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetRecordsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRecordsRequest.Merge(m, src)
}
func (m *GetRecordsRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetRecordsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRecordsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetRecordsRequest proto.InternalMessageInfo

func (m *GetRecordsRequest) GetBody() *GetRecordsRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

type GetRecordsRequest_Body struct {
	// threadID is the target thread's ID.
	ThreadID *ProtoThreadID `protobuf:"bytes,1,opt,name=threadID,proto3,customtype=ProtoThreadID" json:"threadID,omitempty"`
	// serviceKey for the thread.
	ServiceKey *ProtoKey `protobuf:"bytes,2,opt,name=serviceKey,proto3,customtype=ProtoKey" json:"serviceKey,omitempty"`
	// List of requested logs.
	Logs []*GetRecordsRequest_Body_LogEntry `protobuf:"bytes,3,rep,name=logs,proto3" json:"logs,omitempty"`
}

func (m *GetRecordsRequest_Body) Reset()         { *m = GetRecordsRequest_Body{} }
func (m *GetRecordsRequest_Body) String() string { return proto.CompactTextString(m) }
func (*GetRecordsRequest_Body) ProtoMessage()    {}
func (*GetRecordsRequest_Body) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{5, 0}
}
func (m *GetRecordsRequest_Body) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetRecordsRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetRecordsRequest_Body.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetRecordsRequest_Body) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRecordsRequest_Body.Merge(m, src)
}
func (m *GetRecordsRequest_Body) XXX_Size() int {
	return m.Size()
}
func (m *GetRecordsRequest_Body) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRecordsRequest_Body.DiscardUnknown(m)
}

var xxx_messageInfo_GetRecordsRequest_Body proto.InternalMessageInfo

func (m *GetRecordsRequest_Body) GetLogs() []*GetRecordsRequest_Body_LogEntry {
	if m != nil {
		return m.Logs
	}
	return nil
}

// LogEntry represents a single log.
type GetRecordsRequest_Body_LogEntry struct {
	// logID of this entry.
	LogID *ProtoPeerID `protobuf:"bytes,1,opt,name=logID,proto3,customtype=ProtoPeerID" json:"logID,omitempty"`
	// offset tells the recipient at which point to consider records new for the reply.
	Offset *ProtoCid `protobuf:"bytes,2,opt,name=offset,proto3,customtype=ProtoCid" json:"offset,omitempty"`
	// limit indicates the max number of records to return.
	Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	// counter indicates the position of record
	Counter int64 `protobuf:"varint,4,opt,name=counter,proto3" json:"counter,omitempty"`
}

func (m *GetRecordsRequest_Body_LogEntry) Reset()         { *m = GetRecordsRequest_Body_LogEntry{} }
func (m *GetRecordsRequest_Body_LogEntry) String() string { return proto.CompactTextString(m) }
func (*GetRecordsRequest_Body_LogEntry) ProtoMessage()    {}
func (*GetRecordsRequest_Body_LogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{5, 0, 0}
}
func (m *GetRecordsRequest_Body_LogEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetRecordsRequest_Body_LogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetRecordsRequest_Body_LogEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetRecordsRequest_Body_LogEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRecordsRequest_Body_LogEntry.Merge(m, src)
}
func (m *GetRecordsRequest_Body_LogEntry) XXX_Size() int {
	return m.Size()
}
func (m *GetRecordsRequest_Body_LogEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRecordsRequest_Body_LogEntry.DiscardUnknown(m)
}

var xxx_messageInfo_GetRecordsRequest_Body_LogEntry proto.InternalMessageInfo

func (m *GetRecordsRequest_Body_LogEntry) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *GetRecordsRequest_Body_LogEntry) GetCounter() int64 {
	if m != nil {
		return m.Counter
	}
	return 0
}

// GetRecordsReply contains records requested with a GetRecordsRequest.
type GetRecordsReply struct {
	// records are the result of the request.
	Logs []*GetRecordsReply_LogEntry `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"`
}

func (m *GetRecordsReply) Reset()         { *m = GetRecordsReply{} }
func (m *GetRecordsReply) String() string { return proto.CompactTextString(m) }
func (*GetRecordsReply) ProtoMessage()    {}
func (*GetRecordsReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{6}
}
func (m *GetRecordsReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetRecordsReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetRecordsReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetRecordsReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRecordsReply.Merge(m, src)
}
func (m *GetRecordsReply) XXX_Size() int {
	return m.Size()
}
func (m *GetRecordsReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRecordsReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetRecordsReply proto.InternalMessageInfo

func (m *GetRecordsReply) GetLogs() []*GetRecordsReply_LogEntry {
	if m != nil {
		return m.Logs
	}
	return nil
}

// LogEntry represents a single log.
type GetRecordsReply_LogEntry struct {
	// logID of this entry.
	LogID *ProtoPeerID `protobuf:"bytes,1,opt,name=logID,proto3,customtype=ProtoPeerID" json:"logID,omitempty"`
	// records returned for this entry.
	Records []*Log_Record `protobuf:"bytes,2,rep,name=records,proto3" json:"records,omitempty"`
	// log contains new log info that was missing from the request.
	Log *Log `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
}

func (m *GetRecordsReply_LogEntry) Reset()         { *m = GetRecordsReply_LogEntry{} }
func (m *GetRecordsReply_LogEntry) String() string { return proto.CompactTextString(m) }
func (*GetRecordsReply_LogEntry) ProtoMessage()    {}
func (*GetRecordsReply_LogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{6, 0}
}
func (m *GetRecordsReply_LogEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetRecordsReply_LogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetRecordsReply_LogEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetRecordsReply_LogEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetRecordsReply_LogEntry.Merge(m, src)
}
func (m *GetRecordsReply_LogEntry) XXX_Size() int {
	return m.Size()
}
func (m *GetRecordsReply_LogEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_GetRecordsReply_LogEntry.DiscardUnknown(m)
}

var xxx_messageInfo_GetRecordsReply_LogEntry proto.InternalMessageInfo

func (m *GetRecordsReply_LogEntry) GetRecords() []*Log_Record {
	if m != nil {
		return m.Records
	}
	return nil
}

func (m *GetRecordsReply_LogEntry) GetLog() *Log {
	if m != nil {
		return m.Log
	}
	return nil
}

// PushRecordRequest is used to push a log record to a peer.
type PushRecordRequest struct {
	// body is the message body.
	Body *PushRecordRequest_Body `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
	// position of the record
	Counter int64 `protobuf:"varint,3,opt,name=counter,proto3" json:"counter,omitempty"`
}

func (m *PushRecordRequest) Reset()         { *m = PushRecordRequest{} }
func (m *PushRecordRequest) String() string { return proto.CompactTextString(m) }
func (*PushRecordRequest) ProtoMessage()    {}
func (*PushRecordRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{7}
}
func (m *PushRecordRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushRecordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushRecordRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushRecordRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushRecordRequest.Merge(m, src)
}
func (m *PushRecordRequest) XXX_Size() int {
	return m.Size()
}
func (m *PushRecordRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PushRecordRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PushRecordRequest proto.InternalMessageInfo

func (m *PushRecordRequest) GetBody() *PushRecordRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *PushRecordRequest) GetCounter() int64 {
	if m != nil {
		return m.Counter
	}
	return 0
}

type PushRecordRequest_Body struct {
	// threadID is the target thread's ID.
	ThreadID *ProtoThreadID `protobuf:"bytes,1,opt,name=threadID,proto3,customtype=ProtoThreadID" json:"threadID,omitempty"`
	// logID is the target log's ID.
	LogID *ProtoPeerID `protobuf:"bytes,2,opt,name=logID,proto3,customtype=ProtoPeerID" json:"logID,omitempty"`
	// record is the actual record payload.
	Record *Log_Record `protobuf:"bytes,3,opt,name=record,proto3" json:"record,omitempty"`
}

func (m *PushRecordRequest_Body) Reset()         { *m = PushRecordRequest_Body{} }
func (m *PushRecordRequest_Body) String() string { return proto.CompactTextString(m) }
func (*PushRecordRequest_Body) ProtoMessage()    {}
func (*PushRecordRequest_Body) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{7, 0}
}
func (m *PushRecordRequest_Body) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushRecordRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushRecordRequest_Body.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushRecordRequest_Body) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushRecordRequest_Body.Merge(m, src)
}
func (m *PushRecordRequest_Body) XXX_Size() int {
	return m.Size()
}
func (m *PushRecordRequest_Body) XXX_DiscardUnknown() {
	xxx_messageInfo_PushRecordRequest_Body.DiscardUnknown(m)
}

var xxx_messageInfo_PushRecordRequest_Body proto.InternalMessageInfo

func (m *PushRecordRequest_Body) GetRecord() *Log_Record {
	if m != nil {
		return m.Record
	}
	return nil
}

// PushRecordReply is the response from a PushRecordRequest.
type PushRecordReply struct {
}

func (m *PushRecordReply) Reset()         { *m = PushRecordReply{} }
func (m *PushRecordReply) String() string { return proto.CompactTextString(m) }
func (*PushRecordReply) ProtoMessage()    {}
func (*PushRecordReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{8}
}
func (m *PushRecordReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushRecordReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushRecordReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushRecordReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushRecordReply.Merge(m, src)
}
func (m *PushRecordReply) XXX_Size() int {
	return m.Size()
}
func (m *PushRecordReply) XXX_DiscardUnknown() {
	xxx_messageInfo_PushRecordReply.DiscardUnknown(m)
}

var xxx_messageInfo_PushRecordReply proto.InternalMessageInfo

// ExchangeEdgesRequest is used to exchange address/heads edges with a peer.
type ExchangeEdgesRequest struct {
	// body is the message body.
	Body *ExchangeEdgesRequest_Body `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}

func (m *ExchangeEdgesRequest) Reset()         { *m = ExchangeEdgesRequest{} }
func (m *ExchangeEdgesRequest) String() string { return proto.CompactTextString(m) }
func (*ExchangeEdgesRequest) ProtoMessage()    {}
func (*ExchangeEdgesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{9}
}
func (m *ExchangeEdgesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExchangeEdgesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExchangeEdgesRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExchangeEdgesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExchangeEdgesRequest.Merge(m, src)
}
func (m *ExchangeEdgesRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExchangeEdgesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExchangeEdgesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExchangeEdgesRequest proto.InternalMessageInfo

func (m *ExchangeEdgesRequest) GetBody() *ExchangeEdgesRequest_Body {
	if m != nil {
		return m.Body
	}
	return nil
}

type ExchangeEdgesRequest_Body struct {
	// threads is a list of requested thread IDs with its local edges.
	Threads []*ExchangeEdgesRequest_Body_ThreadEntry `protobuf:"bytes,1,rep,name=threads,proto3" json:"threads,omitempty"`
}

func (m *ExchangeEdgesRequest_Body) Reset()         { *m = ExchangeEdgesRequest_Body{} }
func (m *ExchangeEdgesRequest_Body) String() string { return proto.CompactTextString(m) }
func (*ExchangeEdgesRequest_Body) ProtoMessage()    {}
func (*ExchangeEdgesRequest_Body) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{9, 0}
}
func (m *ExchangeEdgesRequest_Body) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExchangeEdgesRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExchangeEdgesRequest_Body.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExchangeEdgesRequest_Body) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExchangeEdgesRequest_Body.Merge(m, src)
}
func (m *ExchangeEdgesRequest_Body) XXX_Size() int {
	return m.Size()
}
func (m *ExchangeEdgesRequest_Body) XXX_DiscardUnknown() {
	xxx_messageInfo_ExchangeEdgesRequest_Body.DiscardUnknown(m)
}

var xxx_messageInfo_ExchangeEdgesRequest_Body proto.InternalMessageInfo

func (m *ExchangeEdgesRequest_Body) GetThreads() []*ExchangeEdgesRequest_Body_ThreadEntry {
	if m != nil {
		return m.Threads
	}
	return nil
}

type ExchangeEdgesRequest_Body_ThreadEntry struct {
	// threadID is the target thread's ID.
	ThreadID *ProtoThreadID `protobuf:"bytes,1,opt,name=threadID,proto3,customtype=ProtoThreadID" json:"threadID,omitempty"`
	// addressEdge is the current hash of peers addresses stored on a requester.
	AddressEdge uint64 `protobuf:"varint,2,opt,name=addressEdge,proto3" json:"addressEdge,omitempty"`
	// headsEdge is the current hash of the log's heads stored on a requester.
	HeadsEdge uint64 `protobuf:"varint,3,opt,name=headsEdge,proto3" json:"headsEdge,omitempty"`
}

func (m *ExchangeEdgesRequest_Body_ThreadEntry) Reset()         { *m = ExchangeEdgesRequest_Body_ThreadEntry{} }
func (m *ExchangeEdgesRequest_Body_ThreadEntry) String() string { return proto.CompactTextString(m) }
func (*ExchangeEdgesRequest_Body_ThreadEntry) ProtoMessage()    {}
func (*ExchangeEdgesRequest_Body_ThreadEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{9, 0, 0}
}
func (m *ExchangeEdgesRequest_Body_ThreadEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExchangeEdgesRequest_Body_ThreadEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExchangeEdgesRequest_Body_ThreadEntry.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExchangeEdgesRequest_Body_ThreadEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExchangeEdgesRequest_Body_ThreadEntry.Merge(m, src)
}
func (m *ExchangeEdgesRequest_Body_ThreadEntry) XXX_Size() int {
	return m.Size()
}
func (m *ExchangeEdgesRequest_Body_ThreadEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_ExchangeEdgesRequest_Body_ThreadEntry.DiscardUnknown(m)
}

var xxx_messageInfo_ExchangeEdgesRequest_Body_ThreadEntry proto.InternalMessageInfo

func (m *ExchangeEdgesRequest_Body_ThreadEntry) GetAddressEdge() uint64 {
	if m != nil {
		return m.AddressEdge
	}
	return 0
}

func (m *ExchangeEdgesRequest_Body_ThreadEntry) GetHeadsEdge() uint64 {
	if m != nil {
		return m.HeadsEdge
	}
	return 0
}

// ExchangeEdgesReply contains edges requested with an ExchangeEdgesRequest.
type ExchangeEdgesReply struct {
	// edges contains edge information about requested threads.
	Edges []*ExchangeEdgesReply_ThreadEdges `protobuf:"bytes,1,rep,name=edges,proto3" json:"edges,omitempty"`
}

func (m *ExchangeEdgesReply) Reset()         { *m = ExchangeEdgesReply{} }
func (m *ExchangeEdgesReply) String() string { return proto.CompactTextString(m) }
func (*ExchangeEdgesReply) ProtoMessage()    {}
func (*ExchangeEdgesReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{10}
}
func (m *ExchangeEdgesReply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExchangeEdgesReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExchangeEdgesReply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExchangeEdgesReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExchangeEdgesReply.Merge(m, src)
}
func (m *ExchangeEdgesReply) XXX_Size() int {
	return m.Size()
}
func (m *ExchangeEdgesReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ExchangeEdgesReply.DiscardUnknown(m)
}

var xxx_messageInfo_ExchangeEdgesReply proto.InternalMessageInfo

func (m *ExchangeEdgesReply) GetEdges() []*ExchangeEdgesReply_ThreadEdges {
	if m != nil {
		return m.Edges
	}
	return nil
}

type ExchangeEdgesReply_ThreadEdges struct {
	// threadID is the requested thread's ID.
	ThreadID *ProtoThreadID `protobuf:"bytes,1,opt,name=threadID,proto3,customtype=ProtoThreadID" json:"threadID,omitempty"`
	// deprecated, use default values for addressEdge and headsEdge
	Exists bool `protobuf:"varint,2,opt,name=exists,proto3" json:"exists,omitempty"`
	// addressEdge is the current hash of peers addresses stored on a respondent.
	AddressEdge uint64 `protobuf:"varint,3,opt,name=addressEdge,proto3" json:"addressEdge,omitempty"`
	// headsEdge is the current hash of the log's heads stored on a respondent.
	HeadsEdge uint64 `protobuf:"varint,4,opt,name=headsEdge,proto3" json:"headsEdge,omitempty"`
}

func (m *ExchangeEdgesReply_ThreadEdges) Reset()         { *m = ExchangeEdgesReply_ThreadEdges{} }
func (m *ExchangeEdgesReply_ThreadEdges) String() string { return proto.CompactTextString(m) }
func (*ExchangeEdgesReply_ThreadEdges) ProtoMessage()    {}
func (*ExchangeEdgesReply_ThreadEdges) Descriptor() ([]byte, []int) {
	return fileDescriptor_a5b10ce944527a32, []int{10, 0}
}
func (m *ExchangeEdgesReply_ThreadEdges) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExchangeEdgesReply_ThreadEdges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExchangeEdgesReply_ThreadEdges.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExchangeEdgesReply_ThreadEdges) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExchangeEdgesReply_ThreadEdges.Merge(m, src)
}
func (m *ExchangeEdgesReply_ThreadEdges) XXX_Size() int {
	return m.Size()
}
func (m *ExchangeEdgesReply_ThreadEdges) XXX_DiscardUnknown() {
	xxx_messageInfo_ExchangeEdgesReply_ThreadEdges.DiscardUnknown(m)
}

var xxx_messageInfo_ExchangeEdgesReply_ThreadEdges proto.InternalMessageInfo

func (m *ExchangeEdgesReply_ThreadEdges) GetExists() bool {
	if m != nil {
		return m.Exists
	}
	return false
}

func (m *ExchangeEdgesReply_ThreadEdges) GetAddressEdge() uint64 {
	if m != nil {
		return m.AddressEdge
	}
	return 0
}

func (m *ExchangeEdgesReply_ThreadEdges) GetHeadsEdge() uint64 {
	if m != nil {
		return m.HeadsEdge
	}
	return 0
}

func init() {
	proto.RegisterType((*Log)(nil), "net.pb.Log")
	proto.RegisterType((*Log_Record)(nil), "net.pb.Log.Record")
	proto.RegisterType((*GetLogsRequest)(nil), "net.pb.GetLogsRequest")
	proto.RegisterType((*GetLogsRequest_Body)(nil), "net.pb.GetLogsRequest.Body")
	proto.RegisterType((*GetLogsReply)(nil), "net.pb.GetLogsReply")
	proto.RegisterType((*PushLogRequest)(nil), "net.pb.PushLogRequest")
	proto.RegisterType((*PushLogRequest_Body)(nil), "net.pb.PushLogRequest.Body")
	proto.RegisterType((*PushLogReply)(nil), "net.pb.PushLogReply")
	proto.RegisterType((*GetRecordsRequest)(nil), "net.pb.GetRecordsRequest")
	proto.RegisterType((*GetRecordsRequest_Body)(nil), "net.pb.GetRecordsRequest.Body")
	proto.RegisterType((*GetRecordsRequest_Body_LogEntry)(nil), "net.pb.GetRecordsRequest.Body.LogEntry")
	proto.RegisterType((*GetRecordsReply)(nil), "net.pb.GetRecordsReply")
	proto.RegisterType((*GetRecordsReply_LogEntry)(nil), "net.pb.GetRecordsReply.LogEntry")
	proto.RegisterType((*PushRecordRequest)(nil), "net.pb.PushRecordRequest")
	proto.RegisterType((*PushRecordRequest_Body)(nil), "net.pb.PushRecordRequest.Body")
	proto.RegisterType((*PushRecordReply)(nil), "net.pb.PushRecordReply")
	proto.RegisterType((*ExchangeEdgesRequest)(nil), "net.pb.ExchangeEdgesRequest")
	proto.RegisterType((*ExchangeEdgesRequest_Body)(nil), "net.pb.ExchangeEdgesRequest.Body")
	proto.RegisterType((*ExchangeEdgesRequest_Body_ThreadEntry)(nil), "net.pb.ExchangeEdgesRequest.Body.ThreadEntry")
	proto.RegisterType((*ExchangeEdgesReply)(nil), "net.pb.ExchangeEdgesReply")
	proto.RegisterType((*ExchangeEdgesReply_ThreadEdges)(nil), "net.pb.ExchangeEdgesReply.ThreadEdges")
}

func init() { proto.RegisterFile("net.proto", fileDescriptor_a5b10ce944527a32) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ServiceClient is the client API for Service service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ServiceClient interface {
	// GetLogs from a peer.
	GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (*GetLogsReply, error)
	// PushLog to a peer.
	PushLog(ctx context.Context, in *PushLogRequest, opts ...grpc.CallOption) (*PushLogReply, error)
	// GetRecords from a peer.
	GetRecords(ctx context.Context, in *GetRecordsRequest, opts ...grpc.CallOption) (*GetRecordsReply, error)
	// PushRecord to a peer.
	PushRecord(ctx context.Context, in *PushRecordRequest, opts ...grpc.CallOption) (*PushRecordReply, error)
	// ExchangeEdges with a peer.
	ExchangeEdges(ctx context.Context, in *ExchangeEdgesRequest, opts ...grpc.CallOption) (*ExchangeEdgesReply, error)
}

type serviceClient struct {
	cc *grpc.ClientConn
}

func NewServiceClient(cc *grpc.ClientConn) ServiceClient {
	return &serviceClient{cc}
}

func (c *serviceClient) GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (*GetLogsReply, error) {
	out := new(GetLogsReply)
	err := c.cc.Invoke(ctx, "/net.pb.Service/GetLogs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) PushLog(ctx context.Context, in *PushLogRequest, opts ...grpc.CallOption) (*PushLogReply, error) {
	out := new(PushLogReply)
	err := c.cc.Invoke(ctx, "/net.pb.Service/PushLog", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) GetRecords(ctx context.Context, in *GetRecordsRequest, opts ...grpc.CallOption) (*GetRecordsReply, error) {
	out := new(GetRecordsReply)
	err := c.cc.Invoke(ctx, "/net.pb.Service/GetRecords", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) PushRecord(ctx context.Context, in *PushRecordRequest, opts ...grpc.CallOption) (*PushRecordReply, error) {
	out := new(PushRecordReply)
	err := c.cc.Invoke(ctx, "/net.pb.Service/PushRecord", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serviceClient) ExchangeEdges(ctx context.Context, in *ExchangeEdgesRequest, opts ...grpc.CallOption) (*ExchangeEdgesReply, error) {
	out := new(ExchangeEdgesReply)
	err := c.cc.Invoke(ctx, "/net.pb.Service/ExchangeEdges", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServiceServer is the server API for Service service.
type ServiceServer interface {
	// GetLogs from a peer.
	GetLogs(context.Context, *GetLogsRequest) (*GetLogsReply, error)
	// PushLog to a peer.
	PushLog(context.Context, *PushLogRequest) (*PushLogReply, error)
	// GetRecords from a peer.
	GetRecords(context.Context, *GetRecordsRequest) (*GetRecordsReply, error)
	// PushRecord to a peer.
	PushRecord(context.Context, *PushRecordRequest) (*PushRecordReply, error)
	// ExchangeEdges with a peer.
	ExchangeEdges(context.Context, *ExchangeEdgesRequest) (*ExchangeEdgesReply, error)
}

// UnimplementedServiceServer can be embedded to have forward compatible implementations.
type UnimplementedServiceServer struct {
}

func (*UnimplementedServiceServer) GetLogs(ctx context.Context, req *GetLogsRequest) (*GetLogsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLogs not implemented")
}
func (*UnimplementedServiceServer) PushLog(ctx context.Context, req *PushLogRequest) (*PushLogReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PushLog not implemented")
}
func (*UnimplementedServiceServer) GetRecords(ctx context.Context, req *GetRecordsRequest) (*GetRecordsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRecords not implemented")
}
func (*UnimplementedServiceServer) PushRecord(ctx context.Context, req *PushRecordRequest) (*PushRecordReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PushRecord not implemented")
}
func (*UnimplementedServiceServer) ExchangeEdges(ctx context.Context, req *ExchangeEdgesRequest) (*ExchangeEdgesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExchangeEdges not implemented")
}

func RegisterServiceServer(s *grpc.Server, srv ServiceServer) {
	s.RegisterService(&_Service_serviceDesc, srv)
}

func _Service_GetLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLogsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).GetLogs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/net.pb.Service/GetLogs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).GetLogs(ctx, req.(*GetLogsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_PushLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushLogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).PushLog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/net.pb.Service/PushLog",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).PushLog(ctx, req.(*PushLogRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_GetRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRecordsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).GetRecords(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/net.pb.Service/GetRecords",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).GetRecords(ctx, req.(*GetRecordsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_PushRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushRecordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).PushRecord(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/net.pb.Service/PushRecord",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).PushRecord(ctx, req.(*PushRecordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Service_ExchangeEdges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExchangeEdgesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServiceServer).ExchangeEdges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/net.pb.Service/ExchangeEdges",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServiceServer).ExchangeEdges(ctx, req.(*ExchangeEdgesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Service_serviceDesc = grpc.ServiceDesc{
	ServiceName: "net.pb.Service",
	HandlerType: (*ServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetLogs",
			Handler:    _Service_GetLogs_Handler,
		},
		{
			MethodName: "PushLog",
			Handler:    _Service_PushLog_Handler,
		},
		{
			MethodName: "GetRecords",
			Handler:    _Service_GetRecords_Handler,
		},
		{
			MethodName: "PushRecord",
			Handler:    _Service_PushRecord_Handler,
		},
		{
			MethodName: "ExchangeEdges",
			Handler:    _Service_ExchangeEdges_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "net.proto",
}

func (m *Log) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Log) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counter != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.Counter))
		i--
		dAtA[i] = 0x28
	}
	if m.Head != nil {
		{
			size := m.Head.Size()
			i -= size
			if _, err := m.Head.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Addrs) > 0 {
		for iNdEx := len(m.Addrs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Addrs[iNdEx].Size()
				i -= size
				if _, err := m.Addrs[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.PubKey != nil {
		{
			size := m.PubKey.Size()
			i -= size
			if _, err := m.PubKey.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size := m.ID.Size()
			i -= size
			if _, err := m.ID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Log_Record) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Log_Record) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Log_Record) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BodyNode) > 0 {
		i -= len(m.BodyNode)
		copy(dAtA[i:], m.BodyNode)
		i = encodeVarintNet(dAtA, i, uint64(len(m.BodyNode)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.HeaderNode) > 0 {
		i -= len(m.HeaderNode)
		copy(dAtA[i:], m.HeaderNode)
		i = encodeVarintNet(dAtA, i, uint64(len(m.HeaderNode)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.EventNode) > 0 {
		i -= len(m.EventNode)
		copy(dAtA[i:], m.EventNode)
		i = encodeVarintNet(dAtA, i, uint64(len(m.EventNode)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordNode) > 0 {
		i -= len(m.RecordNode)
		copy(dAtA[i:], m.RecordNode)
		i = encodeVarintNet(dAtA, i, uint64(len(m.RecordNode)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetLogsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetLogsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLogsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *GetLogsRequest_Body) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetLogsRequest_Body) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLogsRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ServiceKey != nil {
		{
			size := m.ServiceKey.Size()
			i -= size
			if _, err := m.ServiceKey.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ThreadID != nil {
		{
			size := m.ThreadID.Size()
			i -= size
			if _, err := m.ThreadID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetLogsReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetLogsReply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLogsReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *PushLogRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushLogRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushLogRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *PushLogRequest_Body) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushLogRequest_Body) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushLogRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Log != nil {
		{
			size, err := m.Log.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.ReadKey != nil {
		{
			size := m.ReadKey.Size()
			i -= size
			if _, err := m.ReadKey.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ServiceKey != nil {
		{
			size := m.ServiceKey.Size()
			i -= size
			if _, err := m.ServiceKey.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ThreadID != nil {
		{
			size := m.ThreadID.Size()
			i -= size
			if _, err := m.ThreadID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushLogReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushLogReply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushLogReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetRecordsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetRecordsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRecordsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *GetRecordsRequest_Body) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetRecordsRequest_Body) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRecordsRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.ServiceKey != nil {
		{
			size := m.ServiceKey.Size()
			i -= size
			if _, err := m.ServiceKey.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ThreadID != nil {
		{
			size := m.ThreadID.Size()
			i -= size
			if _, err := m.ThreadID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetRecordsRequest_Body_LogEntry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetRecordsRequest_Body_LogEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRecordsRequest_Body_LogEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counter != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.Counter))
		i--
		dAtA[i] = 0x20
	}
	if m.Limit != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x18
	}
	if m.Offset != nil {
		{
			size := m.Offset.Size()
			i -= size
			if _, err := m.Offset.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.LogID != nil {
		{
			size := m.LogID.Size()
			i -= size
			if _, err := m.LogID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetRecordsReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetRecordsReply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRecordsReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetRecordsReply_LogEntry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetRecordsReply_LogEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRecordsReply_LogEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Log != nil {
		{
			size, err := m.Log.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Records) > 0 {
		for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.LogID != nil {
		{
			size := m.LogID.Size()
			i -= size
			if _, err := m.LogID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushRecordRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushRecordRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushRecordRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Counter != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.Counter))
		i--
		dAtA[i] = 0x18
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *PushRecordRequest_Body) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushRecordRequest_Body) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushRecordRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Record != nil {
		{
			size, err := m.Record.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.LogID != nil {
		{
			size := m.LogID.Size()
			i -= size
			if _, err := m.LogID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ThreadID != nil {
		{
			size := m.ThreadID.Size()
			i -= size
			if _, err := m.ThreadID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushRecordReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushRecordReply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushRecordReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *ExchangeEdgesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExchangeEdgesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExchangeEdgesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ExchangeEdgesRequest_Body) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExchangeEdgesRequest_Body) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExchangeEdgesRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Threads) > 0 {
		for iNdEx := len(m.Threads) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Threads[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ExchangeEdgesRequest_Body_ThreadEntry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExchangeEdgesRequest_Body_ThreadEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExchangeEdgesRequest_Body_ThreadEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.HeadsEdge != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.HeadsEdge))
		i--
		dAtA[i] = 0x18
	}
	if m.AddressEdge != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.AddressEdge))
		i--
		dAtA[i] = 0x10
	}
	if m.ThreadID != nil {
		{
			size := m.ThreadID.Size()
			i -= size
			if _, err := m.ThreadID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ExchangeEdgesReply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExchangeEdgesReply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExchangeEdgesReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Edges) > 0 {
		for iNdEx := len(m.Edges) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Edges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNet(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ExchangeEdgesReply_ThreadEdges) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExchangeEdgesReply_ThreadEdges) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExchangeEdgesReply_ThreadEdges) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.HeadsEdge != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.HeadsEdge))
		i--
		dAtA[i] = 0x20
	}
	if m.AddressEdge != 0 {
		i = encodeVarintNet(dAtA, i, uint64(m.AddressEdge))
		i--
		dAtA[i] = 0x18
	}
	if m.Exists {
		i--
		if m.Exists {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.ThreadID != nil {
		{
			size := m.ThreadID.Size()
			i -= size
			if _, err := m.ThreadID.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintNet(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintNet(dAtA []byte, offset int, v uint64) int {
	offset -= sovNet(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedLog(r randyNet, easy bool) *Log {
	this := &Log{}
	this.ID = NewPopulatedProtoPeerID(r)
	this.PubKey = NewPopulatedProtoPubKey(r)
	v1 := r.Intn(10)
	this.Addrs = make([]ProtoAddr, v1)
	for i := 0; i < v1; i++ {
		v2 := NewPopulatedProtoAddr(r)
		this.Addrs[i] = *v2
	}
	this.Head = NewPopulatedProtoCid(r)
	this.Counter = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Counter *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedLog_Record(r randyNet, easy bool) *Log_Record {
	this := &Log_Record{}
	v3 := r.Intn(100)
	this.RecordNode = make([]byte, v3)
	for i := 0; i < v3; i++ {
		this.RecordNode[i] = byte(r.Intn(256))
	}
	v4 := r.Intn(100)
	this.EventNode = make([]byte, v4)
	for i := 0; i < v4; i++ {
		this.EventNode[i] = byte(r.Intn(256))
	}
	v5 := r.Intn(100)
	this.HeaderNode = make([]byte, v5)
	for i := 0; i < v5; i++ {
		this.HeaderNode[i] = byte(r.Intn(256))
	}
	v6 := r.Intn(100)
	this.BodyNode = make([]byte, v6)
	for i := 0; i < v6; i++ {
		this.BodyNode[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetLogsRequest(r randyNet, easy bool) *GetLogsRequest {
	this := &GetLogsRequest{}
	if r.Intn(5) != 0 {
		this.Body = NewPopulatedGetLogsRequest_Body(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetLogsRequest_Body(r randyNet, easy bool) *GetLogsRequest_Body {
	this := &GetLogsRequest_Body{}
	this.ThreadID = NewPopulatedProtoThreadID(r)
	this.ServiceKey = NewPopulatedProtoKey(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetLogsReply(r randyNet, easy bool) *GetLogsReply {
	this := &GetLogsReply{}
	if r.Intn(5) != 0 {
		v7 := r.Intn(5)
		this.Logs = make([]*Log, v7)
		for i := 0; i < v7; i++ {
			this.Logs[i] = NewPopulatedLog(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPushLogRequest(r randyNet, easy bool) *PushLogRequest {
	this := &PushLogRequest{}
	if r.Intn(5) != 0 {
		this.Body = NewPopulatedPushLogRequest_Body(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPushLogRequest_Body(r randyNet, easy bool) *PushLogRequest_Body {
	this := &PushLogRequest_Body{}
	this.ThreadID = NewPopulatedProtoThreadID(r)
	this.ServiceKey = NewPopulatedProtoKey(r)
	this.ReadKey = NewPopulatedProtoKey(r)
	if r.Intn(5) != 0 {
		this.Log = NewPopulatedLog(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPushLogReply(r randyNet, easy bool) *PushLogReply {
	this := &PushLogReply{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetRecordsRequest(r randyNet, easy bool) *GetRecordsRequest {
	this := &GetRecordsRequest{}
	if r.Intn(5) != 0 {
		this.Body = NewPopulatedGetRecordsRequest_Body(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetRecordsRequest_Body(r randyNet, easy bool) *GetRecordsRequest_Body {
	this := &GetRecordsRequest_Body{}
	this.ThreadID = NewPopulatedProtoThreadID(r)
	this.ServiceKey = NewPopulatedProtoKey(r)
	if r.Intn(5) != 0 {
		v8 := r.Intn(5)
		this.Logs = make([]*GetRecordsRequest_Body_LogEntry, v8)
		for i := 0; i < v8; i++ {
			this.Logs[i] = NewPopulatedGetRecordsRequest_Body_LogEntry(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetRecordsRequest_Body_LogEntry(r randyNet, easy bool) *GetRecordsRequest_Body_LogEntry {
	this := &GetRecordsRequest_Body_LogEntry{}
	this.LogID = NewPopulatedProtoPeerID(r)
	this.Offset = NewPopulatedProtoCid(r)
	this.Limit = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Limit *= -1
	}
	this.Counter = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Counter *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetRecordsReply(r randyNet, easy bool) *GetRecordsReply {
	this := &GetRecordsReply{}
	if r.Intn(5) != 0 {
		v9 := r.Intn(5)
		this.Logs = make([]*GetRecordsReply_LogEntry, v9)
		for i := 0; i < v9; i++ {
			this.Logs[i] = NewPopulatedGetRecordsReply_LogEntry(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetRecordsReply_LogEntry(r randyNet, easy bool) *GetRecordsReply_LogEntry {
	this := &GetRecordsReply_LogEntry{}
	this.LogID = NewPopulatedProtoPeerID(r)
	if r.Intn(5) != 0 {
		v10 := r.Intn(5)
		this.Records = make([]*Log_Record, v10)
		for i := 0; i < v10; i++ {
			this.Records[i] = NewPopulatedLog_Record(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		this.Log = NewPopulatedLog(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPushRecordRequest(r randyNet, easy bool) *PushRecordRequest {
	this := &PushRecordRequest{}
	if r.Intn(5) != 0 {
		this.Body = NewPopulatedPushRecordRequest_Body(r, easy)
	}
	this.Counter = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Counter *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPushRecordRequest_Body(r randyNet, easy bool) *PushRecordRequest_Body {
	this := &PushRecordRequest_Body{}
	this.ThreadID = NewPopulatedProtoThreadID(r)
	this.LogID = NewPopulatedProtoPeerID(r)
	if r.Intn(5) != 0 {
		this.Record = NewPopulatedLog_Record(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPushRecordReply(r randyNet, easy bool) *PushRecordReply {
	this := &PushRecordReply{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedExchangeEdgesRequest(r randyNet, easy bool) *ExchangeEdgesRequest {
	this := &ExchangeEdgesRequest{}
	if r.Intn(5) != 0 {
		this.Body = NewPopulatedExchangeEdgesRequest_Body(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedExchangeEdgesRequest_Body(r randyNet, easy bool) *ExchangeEdgesRequest_Body {
	this := &ExchangeEdgesRequest_Body{}
	if r.Intn(5) != 0 {
		v11 := r.Intn(5)
		this.Threads = make([]*ExchangeEdgesRequest_Body_ThreadEntry, v11)
		for i := 0; i < v11; i++ {
			this.Threads[i] = NewPopulatedExchangeEdgesRequest_Body_ThreadEntry(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedExchangeEdgesRequest_Body_ThreadEntry(r randyNet, easy bool) *ExchangeEdgesRequest_Body_ThreadEntry {
	this := &ExchangeEdgesRequest_Body_ThreadEntry{}
	this.ThreadID = NewPopulatedProtoThreadID(r)
	this.AddressEdge = uint64(uint64(r.Uint32()))
	this.HeadsEdge = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedExchangeEdgesReply(r randyNet, easy bool) *ExchangeEdgesReply {
	this := &ExchangeEdgesReply{}
	if r.Intn(5) != 0 {
		v12 := r.Intn(5)
		this.Edges = make([]*ExchangeEdgesReply_ThreadEdges, v12)
		for i := 0; i < v12; i++ {
			this.Edges[i] = NewPopulatedExchangeEdgesReply_ThreadEdges(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedExchangeEdgesReply_ThreadEdges(r randyNet, easy bool) *ExchangeEdgesReply_ThreadEdges {
	this := &ExchangeEdgesReply_ThreadEdges{}
	this.ThreadID = NewPopulatedProtoThreadID(r)
	this.Exists = bool(bool(r.Intn(2) == 0))
	this.AddressEdge = uint64(uint64(r.Uint32()))
	this.HeadsEdge = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyNet interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneNet(r randyNet) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringNet(r randyNet) string {
	v13 := r.Intn(100)
	tmps := make([]rune, v13)
	for i := 0; i < v13; i++ {
		tmps[i] = randUTF8RuneNet(r)
	}
	return string(tmps)
}
func randUnrecognizedNet(r randyNet, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldNet(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldNet(dAtA []byte, r randyNet, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateNet(dAtA, uint64(key))
		v14 := r.Int63()
		if r.Intn(2) == 0 {
			v14 *= -1
		}
		dAtA = encodeVarintPopulateNet(dAtA, uint64(v14))
	case 1:
		dAtA = encodeVarintPopulateNet(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateNet(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateNet(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateNet(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateNet(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Log) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.PubKey != nil {
		l = m.PubKey.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if len(m.Addrs) > 0 {
		for _, e := range m.Addrs {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	if m.Head != nil {
		l = m.Head.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Counter != 0 {
		n += 1 + sovNet(uint64(m.Counter))
	}
	return n
}

func (m *Log_Record) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordNode)
	if l > 0 {
		n += 1 + l + sovNet(uint64(l))
	}
	l = len(m.EventNode)
	if l > 0 {
		n += 1 + l + sovNet(uint64(l))
	}
	l = len(m.HeaderNode)
	if l > 0 {
		n += 1 + l + sovNet(uint64(l))
	}
	l = len(m.BodyNode)
	if l > 0 {
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *GetLogsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *GetLogsRequest_Body) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadID != nil {
		l = m.ThreadID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.ServiceKey != nil {
		l = m.ServiceKey.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *GetLogsReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	return n
}

func (m *PushLogRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *PushLogRequest_Body) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadID != nil {
		l = m.ThreadID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.ServiceKey != nil {
		l = m.ServiceKey.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.ReadKey != nil {
		l = m.ReadKey.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Log != nil {
		l = m.Log.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *PushLogReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetRecordsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *GetRecordsRequest_Body) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadID != nil {
		l = m.ThreadID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.ServiceKey != nil {
		l = m.ServiceKey.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	return n
}

func (m *GetRecordsRequest_Body_LogEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogID != nil {
		l = m.LogID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Offset != nil {
		l = m.Offset.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovNet(uint64(m.Limit))
	}
	if m.Counter != 0 {
		n += 1 + sovNet(uint64(m.Counter))
	}
	return n
}

func (m *GetRecordsReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	return n
}

func (m *GetRecordsReply_LogEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LogID != nil {
		l = m.LogID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	if m.Log != nil {
		l = m.Log.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *PushRecordRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Counter != 0 {
		n += 1 + sovNet(uint64(m.Counter))
	}
	return n
}

func (m *PushRecordRequest_Body) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadID != nil {
		l = m.ThreadID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.LogID != nil {
		l = m.LogID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Record != nil {
		l = m.Record.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *PushRecordReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *ExchangeEdgesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	return n
}

func (m *ExchangeEdgesRequest_Body) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Threads) > 0 {
		for _, e := range m.Threads {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	return n
}

func (m *ExchangeEdgesRequest_Body_ThreadEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadID != nil {
		l = m.ThreadID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.AddressEdge != 0 {
		n += 1 + sovNet(uint64(m.AddressEdge))
	}
	if m.HeadsEdge != 0 {
		n += 1 + sovNet(uint64(m.HeadsEdge))
	}
	return n
}

func (m *ExchangeEdgesReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Edges) > 0 {
		for _, e := range m.Edges {
			l = e.Size()
			n += 1 + l + sovNet(uint64(l))
		}
	}
	return n
}

func (m *ExchangeEdgesReply_ThreadEdges) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ThreadID != nil {
		l = m.ThreadID.Size()
		n += 1 + l + sovNet(uint64(l))
	}
	if m.Exists {
		n += 2
	}
	if m.AddressEdge != 0 {
		n += 1 + sovNet(uint64(m.AddressEdge))
	}
	if m.HeadsEdge != 0 {
		n += 1 + sovNet(uint64(m.HeadsEdge))
	}
	return n
}

func sovNet(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozNet(x uint64) (n int) {
	return sovNet(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Log) 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 ErrIntOverflowNet
			}
			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: Log: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Log: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoPeerID
			m.ID = &v
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoPubKey
			m.PubKey = &v
			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addrs", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoAddr
			m.Addrs = append(m.Addrs, v)
			if err := m.Addrs[len(m.Addrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoCid
			m.Head = &v
			if err := m.Head.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counter", wireType)
			}
			m.Counter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Counter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Log_Record) 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 ErrIntOverflowNet
			}
			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: Record: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Record: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordNode", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordNode = append(m.RecordNode[:0], dAtA[iNdEx:postIndex]...)
			if m.RecordNode == nil {
				m.RecordNode = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventNode", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventNode = append(m.EventNode[:0], dAtA[iNdEx:postIndex]...)
			if m.EventNode == nil {
				m.EventNode = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderNode", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderNode = append(m.HeaderNode[:0], dAtA[iNdEx:postIndex]...)
			if m.HeaderNode == nil {
				m.HeaderNode = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BodyNode", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BodyNode = append(m.BodyNode[:0], dAtA[iNdEx:postIndex]...)
			if m.BodyNode == nil {
				m.BodyNode = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLogsRequest) 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 ErrIntOverflowNet
			}
			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: GetLogsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLogsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &GetLogsRequest_Body{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLogsRequest_Body) 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 ErrIntOverflowNet
			}
			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: Body: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoThreadID
			m.ThreadID = &v
			if err := m.ThreadID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoKey
			m.ServiceKey = &v
			if err := m.ServiceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLogsReply) 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 ErrIntOverflowNet
			}
			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: GetLogsReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLogsReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &Log{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushLogRequest) 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 ErrIntOverflowNet
			}
			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: PushLogRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushLogRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &PushLogRequest_Body{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushLogRequest_Body) 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 ErrIntOverflowNet
			}
			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: Body: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoThreadID
			m.ThreadID = &v
			if err := m.ThreadID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoKey
			m.ServiceKey = &v
			if err := m.ServiceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoKey
			m.ReadKey = &v
			if err := m.ReadKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Log == nil {
				m.Log = &Log{}
			}
			if err := m.Log.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushLogReply) 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 ErrIntOverflowNet
			}
			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: PushLogReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushLogReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRecordsRequest) 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 ErrIntOverflowNet
			}
			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: GetRecordsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &GetRecordsRequest_Body{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRecordsRequest_Body) 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 ErrIntOverflowNet
			}
			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: Body: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoThreadID
			m.ThreadID = &v
			if err := m.ThreadID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoKey
			m.ServiceKey = &v
			if err := m.ServiceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &GetRecordsRequest_Body_LogEntry{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRecordsRequest_Body_LogEntry) 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 ErrIntOverflowNet
			}
			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: LogEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoPeerID
			m.LogID = &v
			if err := m.LogID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoCid
			m.Offset = &v
			if err := m.Offset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counter", wireType)
			}
			m.Counter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Counter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRecordsReply) 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 ErrIntOverflowNet
			}
			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: GetRecordsReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRecordsReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &GetRecordsReply_LogEntry{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRecordsReply_LogEntry) 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 ErrIntOverflowNet
			}
			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: LogEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoPeerID
			m.LogID = &v
			if err := m.LogID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Records = append(m.Records, &Log_Record{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Log == nil {
				m.Log = &Log{}
			}
			if err := m.Log.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushRecordRequest) 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 ErrIntOverflowNet
			}
			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: PushRecordRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushRecordRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &PushRecordRequest_Body{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Counter", wireType)
			}
			m.Counter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Counter |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushRecordRequest_Body) 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 ErrIntOverflowNet
			}
			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: Body: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoThreadID
			m.ThreadID = &v
			if err := m.ThreadID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoPeerID
			m.LogID = &v
			if err := m.LogID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Record", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Record == nil {
				m.Record = &Log_Record{}
			}
			if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushRecordReply) 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 ErrIntOverflowNet
			}
			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: PushRecordReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushRecordReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExchangeEdgesRequest) 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 ErrIntOverflowNet
			}
			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: ExchangeEdgesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExchangeEdgesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &ExchangeEdgesRequest_Body{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExchangeEdgesRequest_Body) 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 ErrIntOverflowNet
			}
			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: Body: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threads", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Threads = append(m.Threads, &ExchangeEdgesRequest_Body_ThreadEntry{})
			if err := m.Threads[len(m.Threads)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExchangeEdgesRequest_Body_ThreadEntry) 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 ErrIntOverflowNet
			}
			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: ThreadEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThreadEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoThreadID
			m.ThreadID = &v
			if err := m.ThreadID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddressEdge", wireType)
			}
			m.AddressEdge = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddressEdge |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadsEdge", wireType)
			}
			m.HeadsEdge = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeadsEdge |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExchangeEdgesReply) 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 ErrIntOverflowNet
			}
			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: ExchangeEdgesReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExchangeEdgesReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Edges", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Edges = append(m.Edges, &ExchangeEdgesReply_ThreadEdges{})
			if err := m.Edges[len(m.Edges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExchangeEdgesReply_ThreadEdges) 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 ErrIntOverflowNet
			}
			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: ThreadEdges: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThreadEdges: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThreadID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNet
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNet
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v ProtoThreadID
			m.ThreadID = &v
			if err := m.ThreadID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exists", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Exists = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddressEdge", wireType)
			}
			m.AddressEdge = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddressEdge |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadsEdge", wireType)
			}
			m.HeadsEdge = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNet
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeadsEdge |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNet(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNet
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipNet(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowNet
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNet
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNet
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthNet
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupNet
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthNet
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthNet        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNet          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupNet = fmt.Errorf("proto: unexpected end of group")
)