dag.pb.go

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

package pb

import (
	bytes "bytes"
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// 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

// DagPutResponse contains the hashes of ipld nodes generated
// by the dag put request
type DagPutResponse struct {
	// an array of hashes (cids) of the root ipld nod
	Hashes []string `protobuf:"bytes,1,rep,name=hashes,proto3" json:"hashes,omitempty"`
}

func (m *DagPutResponse) Reset()      { *m = DagPutResponse{} }
func (*DagPutResponse) ProtoMessage() {}
func (*DagPutResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{0}
}
func (m *DagPutResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DagPutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DagPutResponse.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 *DagPutResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DagPutResponse.Merge(m, src)
}
func (m *DagPutResponse) XXX_Size() int {
	return m.Size()
}
func (m *DagPutResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DagPutResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DagPutResponse proto.InternalMessageInfo

func (m *DagPutResponse) GetHashes() []string {
	if m != nil {
		return m.Hashes
	}
	return nil
}

// DagPut allows us to store arbitrary bytes as a custom IPLD object
type DagPutRequest struct {
	// data that we will be storing
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	// the object encoding type (raw, cbor, protobuf, etc...)
	ObjectEncoding string `protobuf:"bytes,2,opt,name=objectEncoding,proto3" json:"objectEncoding,omitempty"`
	// the serialization format (raw, cbor, protobuf, etc...)
	SerializationFormat string `protobuf:"bytes,3,opt,name=serializationFormat,proto3" json:"serializationFormat,omitempty"`
	// the hash function to to use (sha2-256, sha3-512, etc...)
	HashFunc string `protobuf:"bytes,4,opt,name=hashFunc,proto3" json:"hashFunc,omitempty"`
	// the cid version to use (0, 1)
	CidVersion int64 `protobuf:"varint,5,opt,name=cidVersion,proto3" json:"cidVersion,omitempty"`
}

func (m *DagPutRequest) Reset()      { *m = DagPutRequest{} }
func (*DagPutRequest) ProtoMessage() {}
func (*DagPutRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{1}
}
func (m *DagPutRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DagPutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DagPutRequest.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 *DagPutRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DagPutRequest.Merge(m, src)
}
func (m *DagPutRequest) XXX_Size() int {
	return m.Size()
}
func (m *DagPutRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DagPutRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DagPutRequest proto.InternalMessageInfo

func (m *DagPutRequest) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *DagPutRequest) GetObjectEncoding() string {
	if m != nil {
		return m.ObjectEncoding
	}
	return ""
}

func (m *DagPutRequest) GetSerializationFormat() string {
	if m != nil {
		return m.SerializationFormat
	}
	return ""
}

func (m *DagPutRequest) GetHashFunc() string {
	if m != nil {
		return m.HashFunc
	}
	return ""
}

func (m *DagPutRequest) GetCidVersion() int64 {
	if m != nil {
		return m.CidVersion
	}
	return 0
}

// DagGetRequest is used to retrieve the raw data
// of an ipld dag node for the specified hash. This can
// then be used by libraries like go-ipld-format to
// decoded into a dag object on the client side using
// merkledag.DecodeProtobuf and passing in the returned bytes
type DagGetRequest struct {
	// the hash of the ipld node to get
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *DagGetRequest) Reset()      { *m = DagGetRequest{} }
func (*DagGetRequest) ProtoMessage() {}
func (*DagGetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{2}
}
func (m *DagGetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DagGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DagGetRequest.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 *DagGetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DagGetRequest.Merge(m, src)
}
func (m *DagGetRequest) XXX_Size() int {
	return m.Size()
}
func (m *DagGetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DagGetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DagGetRequest proto.InternalMessageInfo

func (m *DagGetRequest) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

// DagGetResponse is a response to DagGetRequest
// that returns the raw data of the matching ipld node
type DagGetResponse struct {
	// the raw data of the ipld node
	RawData []byte `protobuf:"bytes,1,opt,name=rawData,proto3" json:"rawData,omitempty"`
}

func (m *DagGetResponse) Reset()      { *m = DagGetResponse{} }
func (*DagGetResponse) ProtoMessage() {}
func (*DagGetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{3}
}
func (m *DagGetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DagGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DagGetResponse.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 *DagGetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DagGetResponse.Merge(m, src)
}
func (m *DagGetResponse) XXX_Size() int {
	return m.Size()
}
func (m *DagGetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DagGetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DagGetResponse proto.InternalMessageInfo

func (m *DagGetResponse) GetRawData() []byte {
	if m != nil {
		return m.RawData
	}
	return nil
}

// NewIPLDNodeRequest is used to create a new ipld node
type NewIPLDNodeRequest struct {
	// links are optional hashes to include as links of the node
	// the name is used as the key, while the value of the key is used as the hash
	Links map[string]string `protobuf:"bytes,1,rep,name=links,proto3" json:"links,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// data to store as part of the data field
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// the hash function to to use (sha2-256, sha3-512, etc...)
	HashFunc string `protobuf:"bytes,3,opt,name=hashFunc,proto3" json:"hashFunc,omitempty"`
}

func (m *NewIPLDNodeRequest) Reset()      { *m = NewIPLDNodeRequest{} }
func (*NewIPLDNodeRequest) ProtoMessage() {}
func (*NewIPLDNodeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{4}
}
func (m *NewIPLDNodeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NewIPLDNodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NewIPLDNodeRequest.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 *NewIPLDNodeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NewIPLDNodeRequest.Merge(m, src)
}
func (m *NewIPLDNodeRequest) XXX_Size() int {
	return m.Size()
}
func (m *NewIPLDNodeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_NewIPLDNodeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_NewIPLDNodeRequest proto.InternalMessageInfo

func (m *NewIPLDNodeRequest) GetLinks() map[string]string {
	if m != nil {
		return m.Links
	}
	return nil
}

func (m *NewIPLDNodeRequest) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *NewIPLDNodeRequest) GetHashFunc() string {
	if m != nil {
		return m.HashFunc
	}
	return ""
}

// AddLinksRequest is used to add links to an existing ipld node
type AddLinksRequest struct {
	// links are optional hashes to include as links of the node
	// the name is used as the key, while the value of the key is used as the hash
	Links map[string]string `protobuf:"bytes,1,rep,name=links,proto3" json:"links,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// the hash of the node we want to add lin skto
	Hash string `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	// the hash function to to use (sha2-256, sha3-512, etc...)
	HashFunc string `protobuf:"bytes,3,opt,name=hashFunc,proto3" json:"hashFunc,omitempty"`
}

func (m *AddLinksRequest) Reset()      { *m = AddLinksRequest{} }
func (*AddLinksRequest) ProtoMessage() {}
func (*AddLinksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{5}
}
func (m *AddLinksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddLinksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddLinksRequest.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 *AddLinksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddLinksRequest.Merge(m, src)
}
func (m *AddLinksRequest) XXX_Size() int {
	return m.Size()
}
func (m *AddLinksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AddLinksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AddLinksRequest proto.InternalMessageInfo

func (m *AddLinksRequest) GetLinks() map[string]string {
	if m != nil {
		return m.Links
	}
	return nil
}

func (m *AddLinksRequest) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *AddLinksRequest) GetHashFunc() string {
	if m != nil {
		return m.HashFunc
	}
	return ""
}

// GetLinksRequest is used to return all the links associated with a particular hash
type GetLinksRequest struct {
	// the hash to request links for
	Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *GetLinksRequest) Reset()      { *m = GetLinksRequest{} }
func (*GetLinksRequest) ProtoMessage() {}
func (*GetLinksRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{6}
}
func (m *GetLinksRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLinksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLinksRequest.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 *GetLinksRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLinksRequest.Merge(m, src)
}
func (m *GetLinksRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetLinksRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLinksRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetLinksRequest proto.InternalMessageInfo

func (m *GetLinksRequest) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

// GetLinksResponse returns all the links for the
// associated hash that was requested
type GetLinksResponse struct {
	// each of the links referenced by the requested hash
	Links []*IPLDLink `protobuf:"bytes,1,rep,name=links,proto3" json:"links,omitempty"`
}

func (m *GetLinksResponse) Reset()      { *m = GetLinksResponse{} }
func (*GetLinksResponse) ProtoMessage() {}
func (*GetLinksResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{7}
}
func (m *GetLinksResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetLinksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetLinksResponse.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 *GetLinksResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLinksResponse.Merge(m, src)
}
func (m *GetLinksResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetLinksResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLinksResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetLinksResponse proto.InternalMessageInfo

func (m *GetLinksResponse) GetLinks() []*IPLDLink {
	if m != nil {
		return m.Links
	}
	return nil
}

// An IPFS MerkleDAG Link
type IPLDLink struct {
	// multihash of the target object
	Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// utf string name. should be unique per object
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// cumulative size of target object
	Size_ uint64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
}

func (m *IPLDLink) Reset()      { *m = IPLDLink{} }
func (*IPLDLink) ProtoMessage() {}
func (*IPLDLink) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{8}
}
func (m *IPLDLink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IPLDLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IPLDLink.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 *IPLDLink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPLDLink.Merge(m, src)
}
func (m *IPLDLink) XXX_Size() int {
	return m.Size()
}
func (m *IPLDLink) XXX_DiscardUnknown() {
	xxx_messageInfo_IPLDLink.DiscardUnknown(m)
}

var xxx_messageInfo_IPLDLink proto.InternalMessageInfo

func (m *IPLDLink) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *IPLDLink) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *IPLDLink) GetSize_() uint64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

// An IPFS MerkleDAG Node
type IPLDNode struct {
	// refs to other objects
	Links []*IPLDLink `protobuf:"bytes,2,rep,name=links,proto3" json:"links,omitempty"`
	// opaque user data
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *IPLDNode) Reset()      { *m = IPLDNode{} }
func (*IPLDNode) ProtoMessage() {}
func (*IPLDNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_228b96b95413374c, []int{9}
}
func (m *IPLDNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IPLDNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IPLDNode.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 *IPLDNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPLDNode.Merge(m, src)
}
func (m *IPLDNode) XXX_Size() int {
	return m.Size()
}
func (m *IPLDNode) XXX_DiscardUnknown() {
	xxx_messageInfo_IPLDNode.DiscardUnknown(m)
}

var xxx_messageInfo_IPLDNode proto.InternalMessageInfo

func (m *IPLDNode) GetLinks() []*IPLDLink {
	if m != nil {
		return m.Links
	}
	return nil
}

func (m *IPLDNode) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func init() {
	proto.RegisterType((*DagPutResponse)(nil), "pb.DagPutResponse")
	proto.RegisterType((*DagPutRequest)(nil), "pb.DagPutRequest")
	proto.RegisterType((*DagGetRequest)(nil), "pb.DagGetRequest")
	proto.RegisterType((*DagGetResponse)(nil), "pb.DagGetResponse")
	proto.RegisterType((*NewIPLDNodeRequest)(nil), "pb.NewIPLDNodeRequest")
	proto.RegisterMapType((map[string]string)(nil), "pb.NewIPLDNodeRequest.LinksEntry")
	proto.RegisterType((*AddLinksRequest)(nil), "pb.AddLinksRequest")
	proto.RegisterMapType((map[string]string)(nil), "pb.AddLinksRequest.LinksEntry")
	proto.RegisterType((*GetLinksRequest)(nil), "pb.GetLinksRequest")
	proto.RegisterType((*GetLinksResponse)(nil), "pb.GetLinksResponse")
	proto.RegisterType((*IPLDLink)(nil), "pb.IPLDLink")
	proto.RegisterType((*IPLDNode)(nil), "pb.IPLDNode")
}

func init() { proto.RegisterFile("dag.proto", fileDescriptor_228b96b95413374c) }

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

func (this *DagPutResponse) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DagPutResponse)
	if !ok {
		that2, ok := that.(DagPutResponse)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DagPutResponse")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DagPutResponse but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DagPutResponse but is not nil && this == nil")
	}
	if len(this.Hashes) != len(that1.Hashes) {
		return fmt.Errorf("Hashes this(%v) Not Equal that(%v)", len(this.Hashes), len(that1.Hashes))
	}
	for i := range this.Hashes {
		if this.Hashes[i] != that1.Hashes[i] {
			return fmt.Errorf("Hashes this[%v](%v) Not Equal that[%v](%v)", i, this.Hashes[i], i, that1.Hashes[i])
		}
	}
	return nil
}
func (this *DagPutResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DagPutResponse)
	if !ok {
		that2, ok := that.(DagPutResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Hashes) != len(that1.Hashes) {
		return false
	}
	for i := range this.Hashes {
		if this.Hashes[i] != that1.Hashes[i] {
			return false
		}
	}
	return true
}
func (this *DagPutRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DagPutRequest)
	if !ok {
		that2, ok := that.(DagPutRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DagPutRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DagPutRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DagPutRequest but is not nil && this == nil")
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	if this.ObjectEncoding != that1.ObjectEncoding {
		return fmt.Errorf("ObjectEncoding this(%v) Not Equal that(%v)", this.ObjectEncoding, that1.ObjectEncoding)
	}
	if this.SerializationFormat != that1.SerializationFormat {
		return fmt.Errorf("SerializationFormat this(%v) Not Equal that(%v)", this.SerializationFormat, that1.SerializationFormat)
	}
	if this.HashFunc != that1.HashFunc {
		return fmt.Errorf("HashFunc this(%v) Not Equal that(%v)", this.HashFunc, that1.HashFunc)
	}
	if this.CidVersion != that1.CidVersion {
		return fmt.Errorf("CidVersion this(%v) Not Equal that(%v)", this.CidVersion, that1.CidVersion)
	}
	return nil
}
func (this *DagPutRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DagPutRequest)
	if !ok {
		that2, ok := that.(DagPutRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.ObjectEncoding != that1.ObjectEncoding {
		return false
	}
	if this.SerializationFormat != that1.SerializationFormat {
		return false
	}
	if this.HashFunc != that1.HashFunc {
		return false
	}
	if this.CidVersion != that1.CidVersion {
		return false
	}
	return true
}
func (this *DagGetRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DagGetRequest)
	if !ok {
		that2, ok := that.(DagGetRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DagGetRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DagGetRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DagGetRequest but is not nil && this == nil")
	}
	if this.Hash != that1.Hash {
		return fmt.Errorf("Hash this(%v) Not Equal that(%v)", this.Hash, that1.Hash)
	}
	return nil
}
func (this *DagGetRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DagGetRequest)
	if !ok {
		that2, ok := that.(DagGetRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Hash != that1.Hash {
		return false
	}
	return true
}
func (this *DagGetResponse) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DagGetResponse)
	if !ok {
		that2, ok := that.(DagGetResponse)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DagGetResponse")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DagGetResponse but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DagGetResponse but is not nil && this == nil")
	}
	if !bytes.Equal(this.RawData, that1.RawData) {
		return fmt.Errorf("RawData this(%v) Not Equal that(%v)", this.RawData, that1.RawData)
	}
	return nil
}
func (this *DagGetResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DagGetResponse)
	if !ok {
		that2, ok := that.(DagGetResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.RawData, that1.RawData) {
		return false
	}
	return true
}
func (this *NewIPLDNodeRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*NewIPLDNodeRequest)
	if !ok {
		that2, ok := that.(NewIPLDNodeRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *NewIPLDNodeRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *NewIPLDNodeRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *NewIPLDNodeRequest but is not nil && this == nil")
	}
	if len(this.Links) != len(that1.Links) {
		return fmt.Errorf("Links this(%v) Not Equal that(%v)", len(this.Links), len(that1.Links))
	}
	for i := range this.Links {
		if this.Links[i] != that1.Links[i] {
			return fmt.Errorf("Links this[%v](%v) Not Equal that[%v](%v)", i, this.Links[i], i, that1.Links[i])
		}
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	if this.HashFunc != that1.HashFunc {
		return fmt.Errorf("HashFunc this(%v) Not Equal that(%v)", this.HashFunc, that1.HashFunc)
	}
	return nil
}
func (this *NewIPLDNodeRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NewIPLDNodeRequest)
	if !ok {
		that2, ok := that.(NewIPLDNodeRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Links) != len(that1.Links) {
		return false
	}
	for i := range this.Links {
		if this.Links[i] != that1.Links[i] {
			return false
		}
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.HashFunc != that1.HashFunc {
		return false
	}
	return true
}
func (this *AddLinksRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*AddLinksRequest)
	if !ok {
		that2, ok := that.(AddLinksRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *AddLinksRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *AddLinksRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *AddLinksRequest but is not nil && this == nil")
	}
	if len(this.Links) != len(that1.Links) {
		return fmt.Errorf("Links this(%v) Not Equal that(%v)", len(this.Links), len(that1.Links))
	}
	for i := range this.Links {
		if this.Links[i] != that1.Links[i] {
			return fmt.Errorf("Links this[%v](%v) Not Equal that[%v](%v)", i, this.Links[i], i, that1.Links[i])
		}
	}
	if this.Hash != that1.Hash {
		return fmt.Errorf("Hash this(%v) Not Equal that(%v)", this.Hash, that1.Hash)
	}
	if this.HashFunc != that1.HashFunc {
		return fmt.Errorf("HashFunc this(%v) Not Equal that(%v)", this.HashFunc, that1.HashFunc)
	}
	return nil
}
func (this *AddLinksRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AddLinksRequest)
	if !ok {
		that2, ok := that.(AddLinksRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Links) != len(that1.Links) {
		return false
	}
	for i := range this.Links {
		if this.Links[i] != that1.Links[i] {
			return false
		}
	}
	if this.Hash != that1.Hash {
		return false
	}
	if this.HashFunc != that1.HashFunc {
		return false
	}
	return true
}
func (this *GetLinksRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*GetLinksRequest)
	if !ok {
		that2, ok := that.(GetLinksRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *GetLinksRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *GetLinksRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *GetLinksRequest but is not nil && this == nil")
	}
	if this.Hash != that1.Hash {
		return fmt.Errorf("Hash this(%v) Not Equal that(%v)", this.Hash, that1.Hash)
	}
	return nil
}
func (this *GetLinksRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetLinksRequest)
	if !ok {
		that2, ok := that.(GetLinksRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Hash != that1.Hash {
		return false
	}
	return true
}
func (this *GetLinksResponse) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*GetLinksResponse)
	if !ok {
		that2, ok := that.(GetLinksResponse)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *GetLinksResponse")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *GetLinksResponse but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *GetLinksResponse but is not nil && this == nil")
	}
	if len(this.Links) != len(that1.Links) {
		return fmt.Errorf("Links this(%v) Not Equal that(%v)", len(this.Links), len(that1.Links))
	}
	for i := range this.Links {
		if !this.Links[i].Equal(that1.Links[i]) {
			return fmt.Errorf("Links this[%v](%v) Not Equal that[%v](%v)", i, this.Links[i], i, that1.Links[i])
		}
	}
	return nil
}
func (this *GetLinksResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetLinksResponse)
	if !ok {
		that2, ok := that.(GetLinksResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Links) != len(that1.Links) {
		return false
	}
	for i := range this.Links {
		if !this.Links[i].Equal(that1.Links[i]) {
			return false
		}
	}
	return true
}
func (this *IPLDLink) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*IPLDLink)
	if !ok {
		that2, ok := that.(IPLDLink)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *IPLDLink")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *IPLDLink but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *IPLDLink but is not nil && this == nil")
	}
	if !bytes.Equal(this.Hash, that1.Hash) {
		return fmt.Errorf("Hash this(%v) Not Equal that(%v)", this.Hash, that1.Hash)
	}
	if this.Name != that1.Name {
		return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
	}
	if this.Size_ != that1.Size_ {
		return fmt.Errorf("Size_ this(%v) Not Equal that(%v)", this.Size_, that1.Size_)
	}
	return nil
}
func (this *IPLDLink) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IPLDLink)
	if !ok {
		that2, ok := that.(IPLDLink)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Hash, that1.Hash) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Size_ != that1.Size_ {
		return false
	}
	return true
}
func (this *IPLDNode) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*IPLDNode)
	if !ok {
		that2, ok := that.(IPLDNode)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *IPLDNode")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *IPLDNode but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *IPLDNode but is not nil && this == nil")
	}
	if len(this.Links) != len(that1.Links) {
		return fmt.Errorf("Links this(%v) Not Equal that(%v)", len(this.Links), len(that1.Links))
	}
	for i := range this.Links {
		if !this.Links[i].Equal(that1.Links[i]) {
			return fmt.Errorf("Links this[%v](%v) Not Equal that[%v](%v)", i, this.Links[i], i, that1.Links[i])
		}
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	return nil
}
func (this *IPLDNode) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IPLDNode)
	if !ok {
		that2, ok := that.(IPLDNode)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Links) != len(that1.Links) {
		return false
	}
	for i := range this.Links {
		if !this.Links[i].Equal(that1.Links[i]) {
			return false
		}
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (this *DagPutResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.DagPutResponse{")
	s = append(s, "Hashes: "+fmt.Sprintf("%#v", this.Hashes)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DagPutRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&pb.DagPutRequest{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "ObjectEncoding: "+fmt.Sprintf("%#v", this.ObjectEncoding)+",\n")
	s = append(s, "SerializationFormat: "+fmt.Sprintf("%#v", this.SerializationFormat)+",\n")
	s = append(s, "HashFunc: "+fmt.Sprintf("%#v", this.HashFunc)+",\n")
	s = append(s, "CidVersion: "+fmt.Sprintf("%#v", this.CidVersion)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DagGetRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.DagGetRequest{")
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DagGetResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.DagGetResponse{")
	s = append(s, "RawData: "+fmt.Sprintf("%#v", this.RawData)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NewIPLDNodeRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&pb.NewIPLDNodeRequest{")
	keysForLinks := make([]string, 0, len(this.Links))
	for k := range this.Links {
		keysForLinks = append(keysForLinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLinks)
	mapStringForLinks := "map[string]string{"
	for _, k := range keysForLinks {
		mapStringForLinks += fmt.Sprintf("%#v: %#v,", k, this.Links[k])
	}
	mapStringForLinks += "}"
	if this.Links != nil {
		s = append(s, "Links: "+mapStringForLinks+",\n")
	}
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "HashFunc: "+fmt.Sprintf("%#v", this.HashFunc)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AddLinksRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&pb.AddLinksRequest{")
	keysForLinks := make([]string, 0, len(this.Links))
	for k := range this.Links {
		keysForLinks = append(keysForLinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLinks)
	mapStringForLinks := "map[string]string{"
	for _, k := range keysForLinks {
		mapStringForLinks += fmt.Sprintf("%#v: %#v,", k, this.Links[k])
	}
	mapStringForLinks += "}"
	if this.Links != nil {
		s = append(s, "Links: "+mapStringForLinks+",\n")
	}
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\n")
	s = append(s, "HashFunc: "+fmt.Sprintf("%#v", this.HashFunc)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetLinksRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.GetLinksRequest{")
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetLinksResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&pb.GetLinksResponse{")
	if this.Links != nil {
		s = append(s, "Links: "+fmt.Sprintf("%#v", this.Links)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IPLDLink) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&pb.IPLDLink{")
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Size_: "+fmt.Sprintf("%#v", this.Size_)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *IPLDNode) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&pb.IPLDNode{")
	if this.Links != nil {
		s = append(s, "Links: "+fmt.Sprintf("%#v", this.Links)+",\n")
	}
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringDag(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// 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

// DagAPIClient is the client API for DagAPI service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DagAPIClient interface {
	// DagPut is used to store arbitrary bytes as a custom IPLD object
	DagPut(ctx context.Context, in *DagPutRequest, opts ...grpc.CallOption) (*DagPutResponse, error)
	// DagGet is used to request the raw ipld node data for an IPLD object
	DagGet(ctx context.Context, in *DagGetRequest, opts ...grpc.CallOption) (*DagGetResponse, error)
	// NewIPLDNode is used to create a new IPFS MerkleDAG node.
	// This is the same type as in github.com/ipfs/go-ipld-format.Node
	NewIPLDNode(ctx context.Context, in *NewIPLDNodeRequest, opts ...grpc.CallOption) (*DagPutResponse, error)
	// AddLinksToNode is used to add links to an existing IPFS MerkleDAG node
	AddLinksToNode(ctx context.Context, in *AddLinksRequest, opts ...grpc.CallOption) (*DagPutResponse, error)
	// GetLinks is used to request all the links for a given object
	GetLinks(ctx context.Context, in *GetLinksRequest, opts ...grpc.CallOption) (*GetLinksResponse, error)
}

type dagAPIClient struct {
	cc *grpc.ClientConn
}

func NewDagAPIClient(cc *grpc.ClientConn) DagAPIClient {
	return &dagAPIClient{cc}
}

func (c *dagAPIClient) DagPut(ctx context.Context, in *DagPutRequest, opts ...grpc.CallOption) (*DagPutResponse, error) {
	out := new(DagPutResponse)
	err := c.cc.Invoke(ctx, "/pb.DagAPI/DagPut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dagAPIClient) DagGet(ctx context.Context, in *DagGetRequest, opts ...grpc.CallOption) (*DagGetResponse, error) {
	out := new(DagGetResponse)
	err := c.cc.Invoke(ctx, "/pb.DagAPI/DagGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dagAPIClient) NewIPLDNode(ctx context.Context, in *NewIPLDNodeRequest, opts ...grpc.CallOption) (*DagPutResponse, error) {
	out := new(DagPutResponse)
	err := c.cc.Invoke(ctx, "/pb.DagAPI/NewIPLDNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dagAPIClient) AddLinksToNode(ctx context.Context, in *AddLinksRequest, opts ...grpc.CallOption) (*DagPutResponse, error) {
	out := new(DagPutResponse)
	err := c.cc.Invoke(ctx, "/pb.DagAPI/AddLinksToNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dagAPIClient) GetLinks(ctx context.Context, in *GetLinksRequest, opts ...grpc.CallOption) (*GetLinksResponse, error) {
	out := new(GetLinksResponse)
	err := c.cc.Invoke(ctx, "/pb.DagAPI/GetLinks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DagAPIServer is the server API for DagAPI service.
type DagAPIServer interface {
	// DagPut is used to store arbitrary bytes as a custom IPLD object
	DagPut(context.Context, *DagPutRequest) (*DagPutResponse, error)
	// DagGet is used to request the raw ipld node data for an IPLD object
	DagGet(context.Context, *DagGetRequest) (*DagGetResponse, error)
	// NewIPLDNode is used to create a new IPFS MerkleDAG node.
	// This is the same type as in github.com/ipfs/go-ipld-format.Node
	NewIPLDNode(context.Context, *NewIPLDNodeRequest) (*DagPutResponse, error)
	// AddLinksToNode is used to add links to an existing IPFS MerkleDAG node
	AddLinksToNode(context.Context, *AddLinksRequest) (*DagPutResponse, error)
	// GetLinks is used to request all the links for a given object
	GetLinks(context.Context, *GetLinksRequest) (*GetLinksResponse, error)
}

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

func (*UnimplementedDagAPIServer) DagPut(ctx context.Context, req *DagPutRequest) (*DagPutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DagPut not implemented")
}
func (*UnimplementedDagAPIServer) DagGet(ctx context.Context, req *DagGetRequest) (*DagGetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DagGet not implemented")
}
func (*UnimplementedDagAPIServer) NewIPLDNode(ctx context.Context, req *NewIPLDNodeRequest) (*DagPutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NewIPLDNode not implemented")
}
func (*UnimplementedDagAPIServer) AddLinksToNode(ctx context.Context, req *AddLinksRequest) (*DagPutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddLinksToNode not implemented")
}
func (*UnimplementedDagAPIServer) GetLinks(ctx context.Context, req *GetLinksRequest) (*GetLinksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLinks not implemented")
}

func RegisterDagAPIServer(s *grpc.Server, srv DagAPIServer) {
	s.RegisterService(&_DagAPI_serviceDesc, srv)
}

func _DagAPI_DagPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DagPutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DagAPIServer).DagPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.DagAPI/DagPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DagAPIServer).DagPut(ctx, req.(*DagPutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DagAPI_DagGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DagGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DagAPIServer).DagGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.DagAPI/DagGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DagAPIServer).DagGet(ctx, req.(*DagGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DagAPI_NewIPLDNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NewIPLDNodeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DagAPIServer).NewIPLDNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.DagAPI/NewIPLDNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DagAPIServer).NewIPLDNode(ctx, req.(*NewIPLDNodeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DagAPI_AddLinksToNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddLinksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DagAPIServer).AddLinksToNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.DagAPI/AddLinksToNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DagAPIServer).AddLinksToNode(ctx, req.(*AddLinksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DagAPI_GetLinks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLinksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DagAPIServer).GetLinks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.DagAPI/GetLinks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DagAPIServer).GetLinks(ctx, req.(*GetLinksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _DagAPI_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.DagAPI",
	HandlerType: (*DagAPIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DagPut",
			Handler:    _DagAPI_DagPut_Handler,
		},
		{
			MethodName: "DagGet",
			Handler:    _DagAPI_DagGet_Handler,
		},
		{
			MethodName: "NewIPLDNode",
			Handler:    _DagAPI_NewIPLDNode_Handler,
		},
		{
			MethodName: "AddLinksToNode",
			Handler:    _DagAPI_AddLinksToNode_Handler,
		},
		{
			MethodName: "GetLinks",
			Handler:    _DagAPI_GetLinks_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dag.proto",
}

func (m *DagPutResponse) 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 *DagPutResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DagPutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hashes) > 0 {
		for iNdEx := len(m.Hashes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Hashes[iNdEx])
			copy(dAtA[i:], m.Hashes[iNdEx])
			i = encodeVarintDag(dAtA, i, uint64(len(m.Hashes[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DagPutRequest) 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 *DagPutRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DagPutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CidVersion != 0 {
		i = encodeVarintDag(dAtA, i, uint64(m.CidVersion))
		i--
		dAtA[i] = 0x28
	}
	if len(m.HashFunc) > 0 {
		i -= len(m.HashFunc)
		copy(dAtA[i:], m.HashFunc)
		i = encodeVarintDag(dAtA, i, uint64(len(m.HashFunc)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SerializationFormat) > 0 {
		i -= len(m.SerializationFormat)
		copy(dAtA[i:], m.SerializationFormat)
		i = encodeVarintDag(dAtA, i, uint64(len(m.SerializationFormat)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ObjectEncoding) > 0 {
		i -= len(m.ObjectEncoding)
		copy(dAtA[i:], m.ObjectEncoding)
		i = encodeVarintDag(dAtA, i, uint64(len(m.ObjectEncoding)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DagGetRequest) 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 *DagGetRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DagGetRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DagGetResponse) 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 *DagGetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DagGetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RawData) > 0 {
		i -= len(m.RawData)
		copy(dAtA[i:], m.RawData)
		i = encodeVarintDag(dAtA, i, uint64(len(m.RawData)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NewIPLDNodeRequest) 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 *NewIPLDNodeRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NewIPLDNodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HashFunc) > 0 {
		i -= len(m.HashFunc)
		copy(dAtA[i:], m.HashFunc)
		i = encodeVarintDag(dAtA, i, uint64(len(m.HashFunc)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Links) > 0 {
		for k := range m.Links {
			v := m.Links[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintDag(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDag(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDag(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AddLinksRequest) 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 *AddLinksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddLinksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HashFunc) > 0 {
		i -= len(m.HashFunc)
		copy(dAtA[i:], m.HashFunc)
		i = encodeVarintDag(dAtA, i, uint64(len(m.HashFunc)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Links) > 0 {
		for k := range m.Links {
			v := m.Links[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintDag(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDag(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDag(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetLinksRequest) 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 *GetLinksRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetLinksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetLinksResponse) 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 *GetLinksResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *IPLDLink) 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 *IPLDLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IPLDLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Size_ != 0 {
		i = encodeVarintDag(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintDag(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IPLDNode) 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 *IPLDNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintDag(dAtA []byte, offset int, v uint64) int {
	offset -= sovDag(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedDagPutResponse(r randyDag, easy bool) *DagPutResponse {
	this := &DagPutResponse{}
	v1 := r.Intn(10)
	this.Hashes = make([]string, v1)
	for i := 0; i < v1; i++ {
		this.Hashes[i] = string(randStringDag(r))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDagPutRequest(r randyDag, easy bool) *DagPutRequest {
	this := &DagPutRequest{}
	v2 := r.Intn(100)
	this.Data = make([]byte, v2)
	for i := 0; i < v2; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	this.ObjectEncoding = string(randStringDag(r))
	this.SerializationFormat = string(randStringDag(r))
	this.HashFunc = string(randStringDag(r))
	this.CidVersion = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CidVersion *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDagGetRequest(r randyDag, easy bool) *DagGetRequest {
	this := &DagGetRequest{}
	this.Hash = string(randStringDag(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDagGetResponse(r randyDag, easy bool) *DagGetResponse {
	this := &DagGetResponse{}
	v3 := r.Intn(100)
	this.RawData = make([]byte, v3)
	for i := 0; i < v3; i++ {
		this.RawData[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedNewIPLDNodeRequest(r randyDag, easy bool) *NewIPLDNodeRequest {
	this := &NewIPLDNodeRequest{}
	if r.Intn(5) != 0 {
		v4 := r.Intn(10)
		this.Links = make(map[string]string)
		for i := 0; i < v4; i++ {
			this.Links[randStringDag(r)] = randStringDag(r)
		}
	}
	v5 := r.Intn(100)
	this.Data = make([]byte, v5)
	for i := 0; i < v5; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	this.HashFunc = string(randStringDag(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedAddLinksRequest(r randyDag, easy bool) *AddLinksRequest {
	this := &AddLinksRequest{}
	if r.Intn(5) != 0 {
		v6 := r.Intn(10)
		this.Links = make(map[string]string)
		for i := 0; i < v6; i++ {
			this.Links[randStringDag(r)] = randStringDag(r)
		}
	}
	this.Hash = string(randStringDag(r))
	this.HashFunc = string(randStringDag(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetLinksRequest(r randyDag, easy bool) *GetLinksRequest {
	this := &GetLinksRequest{}
	this.Hash = string(randStringDag(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetLinksResponse(r randyDag, easy bool) *GetLinksResponse {
	this := &GetLinksResponse{}
	if r.Intn(5) != 0 {
		v7 := r.Intn(5)
		this.Links = make([]*IPLDLink, v7)
		for i := 0; i < v7; i++ {
			this.Links[i] = NewPopulatedIPLDLink(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedIPLDLink(r randyDag, easy bool) *IPLDLink {
	this := &IPLDLink{}
	v8 := r.Intn(100)
	this.Hash = make([]byte, v8)
	for i := 0; i < v8; i++ {
		this.Hash[i] = byte(r.Intn(256))
	}
	this.Name = string(randStringDag(r))
	this.Size_ = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedIPLDNode(r randyDag, easy bool) *IPLDNode {
	this := &IPLDNode{}
	v9 := r.Intn(100)
	this.Data = make([]byte, v9)
	for i := 0; i < v9; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	if r.Intn(5) != 0 {
		v10 := r.Intn(5)
		this.Links = make([]*IPLDLink, v10)
		for i := 0; i < v10; i++ {
			this.Links[i] = NewPopulatedIPLDLink(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

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

func randUTF8RuneDag(r randyDag) 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 randStringDag(r randyDag) string {
	v11 := r.Intn(100)
	tmps := make([]rune, v11)
	for i := 0; i < v11; i++ {
		tmps[i] = randUTF8RuneDag(r)
	}
	return string(tmps)
}
func randUnrecognizedDag(r randyDag, 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 = randFieldDag(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldDag(dAtA []byte, r randyDag, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateDag(dAtA, uint64(key))
		v12 := r.Int63()
		if r.Intn(2) == 0 {
			v12 *= -1
		}
		dAtA = encodeVarintPopulateDag(dAtA, uint64(v12))
	case 1:
		dAtA = encodeVarintPopulateDag(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 = encodeVarintPopulateDag(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateDag(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateDag(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 encodeVarintPopulateDag(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 *DagPutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Hashes) > 0 {
		for _, s := range m.Hashes {
			l = len(s)
			n += 1 + l + sovDag(uint64(l))
		}
	}
	return n
}

func (m *DagPutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	l = len(m.ObjectEncoding)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	l = len(m.SerializationFormat)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	l = len(m.HashFunc)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	if m.CidVersion != 0 {
		n += 1 + sovDag(uint64(m.CidVersion))
	}
	return n
}

func (m *DagGetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	return n
}

func (m *DagGetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RawData)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	return n
}

func (m *NewIPLDNodeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Links) > 0 {
		for k, v := range m.Links {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovDag(uint64(len(k))) + 1 + len(v) + sovDag(uint64(len(v)))
			n += mapEntrySize + 1 + sovDag(uint64(mapEntrySize))
		}
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	l = len(m.HashFunc)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	return n
}

func (m *AddLinksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Links) > 0 {
		for k, v := range m.Links {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovDag(uint64(len(k))) + 1 + len(v) + sovDag(uint64(len(v)))
			n += mapEntrySize + 1 + sovDag(uint64(mapEntrySize))
		}
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	l = len(m.HashFunc)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	return n
}

func (m *GetLinksRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	return n
}

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

func (m *IPLDLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDag(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovDag(uint64(m.Size_))
	}
	return n
}

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

func sovDag(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDag(x uint64) (n int) {
	return sovDag(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *DagPutResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DagPutResponse{`,
		`Hashes:` + fmt.Sprintf("%v", this.Hashes) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DagPutRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DagPutRequest{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`ObjectEncoding:` + fmt.Sprintf("%v", this.ObjectEncoding) + `,`,
		`SerializationFormat:` + fmt.Sprintf("%v", this.SerializationFormat) + `,`,
		`HashFunc:` + fmt.Sprintf("%v", this.HashFunc) + `,`,
		`CidVersion:` + fmt.Sprintf("%v", this.CidVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DagGetRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DagGetRequest{`,
		`Hash:` + fmt.Sprintf("%v", this.Hash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DagGetResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DagGetResponse{`,
		`RawData:` + fmt.Sprintf("%v", this.RawData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NewIPLDNodeRequest) String() string {
	if this == nil {
		return "nil"
	}
	keysForLinks := make([]string, 0, len(this.Links))
	for k := range this.Links {
		keysForLinks = append(keysForLinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLinks)
	mapStringForLinks := "map[string]string{"
	for _, k := range keysForLinks {
		mapStringForLinks += fmt.Sprintf("%v: %v,", k, this.Links[k])
	}
	mapStringForLinks += "}"
	s := strings.Join([]string{`&NewIPLDNodeRequest{`,
		`Links:` + mapStringForLinks + `,`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`HashFunc:` + fmt.Sprintf("%v", this.HashFunc) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AddLinksRequest) String() string {
	if this == nil {
		return "nil"
	}
	keysForLinks := make([]string, 0, len(this.Links))
	for k := range this.Links {
		keysForLinks = append(keysForLinks, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLinks)
	mapStringForLinks := "map[string]string{"
	for _, k := range keysForLinks {
		mapStringForLinks += fmt.Sprintf("%v: %v,", k, this.Links[k])
	}
	mapStringForLinks += "}"
	s := strings.Join([]string{`&AddLinksRequest{`,
		`Links:` + mapStringForLinks + `,`,
		`Hash:` + fmt.Sprintf("%v", this.Hash) + `,`,
		`HashFunc:` + fmt.Sprintf("%v", this.HashFunc) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetLinksRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetLinksRequest{`,
		`Hash:` + fmt.Sprintf("%v", this.Hash) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetLinksResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForLinks := "[]*IPLDLink{"
	for _, f := range this.Links {
		repeatedStringForLinks += strings.Replace(f.String(), "IPLDLink", "IPLDLink", 1) + ","
	}
	repeatedStringForLinks += "}"
	s := strings.Join([]string{`&GetLinksResponse{`,
		`Links:` + repeatedStringForLinks + `,`,
		`}`,
	}, "")
	return s
}
func (this *IPLDLink) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IPLDLink{`,
		`Hash:` + fmt.Sprintf("%v", this.Hash) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Size_:` + fmt.Sprintf("%v", this.Size_) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IPLDNode) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForLinks := "[]*IPLDLink{"
	for _, f := range this.Links {
		repeatedStringForLinks += strings.Replace(f.String(), "IPLDLink", "IPLDLink", 1) + ","
	}
	repeatedStringForLinks += "}"
	s := strings.Join([]string{`&IPLDNode{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Links:` + repeatedStringForLinks + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringDag(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *DagPutResponse) 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 ErrIntOverflowDag
			}
			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: DagPutResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DagPutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hashes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hashes = append(m.Hashes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DagPutRequest) 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 ErrIntOverflowDag
			}
			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: DagPutRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DagPutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectEncoding", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectEncoding = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SerializationFormat", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SerializationFormat = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HashFunc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HashFunc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CidVersion", wireType)
			}
			m.CidVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CidVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DagGetRequest) 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 ErrIntOverflowDag
			}
			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: DagGetRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DagGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NewIPLDNodeRequest) 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 ErrIntOverflowDag
			}
			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: NewIPLDNodeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NewIPLDNodeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Links == nil {
				m.Links = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDag
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDag
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthDag
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDag
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDag
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthDag
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthDag
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDag(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthDag
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Links[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HashFunc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HashFunc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddLinksRequest) 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 ErrIntOverflowDag
			}
			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: AddLinksRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddLinksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Links == nil {
				m.Links = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDag
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDag
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthDag
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDag
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDag
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthDag
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthDag
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDag(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthDag
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Links[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HashFunc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HashFunc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetLinksRequest) 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 ErrIntOverflowDag
			}
			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: GetLinksRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLinksRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPLDLink) 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 ErrIntOverflowDag
			}
			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: IPLDLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPLDLink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
			if m.Hash == nil {
				m.Hash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDag
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDag
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDag
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDag(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDag
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDag(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, ErrIntOverflowDag
			}
			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, ErrIntOverflowDag
				}
				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, ErrIntOverflowDag
				}
				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, ErrInvalidLengthDag
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupDag
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthDag
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthDag        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDag          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDag = fmt.Errorf("proto: unexpected end of group")
)