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

package db

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_syncthing_syncthing_lib_protocol "github.com/syncthing/syncthing/lib/protocol"
	protocol "github.com/syncthing/syncthing/lib/protocol"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type FileVersion struct {
	Version        protocol.Vector `protobuf:"bytes,1,opt,name=version,proto3" json:"version"`
	Deleted        bool            `protobuf:"varint,2,opt,name=deleted,proto3" json:"deleted,omitempty"`
	Devices        [][]byte        `protobuf:"bytes,3,rep,name=devices,proto3" json:"devices,omitempty"`
	InvalidDevices [][]byte        `protobuf:"bytes,4,rep,name=invalid_devices,json=invalidDevices,proto3" json:"invalid_devices,omitempty"`
}

func (m *FileVersion) Reset()         { *m = FileVersion{} }
func (m *FileVersion) String() string { return proto.CompactTextString(m) }
func (*FileVersion) ProtoMessage()    {}
func (*FileVersion) Descriptor() ([]byte, []int) {
	return fileDescriptor_e774e8f5f348d14d, []int{0}
}
func (m *FileVersion) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileVersion.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 *FileVersion) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileVersion.Merge(m, src)
}
func (m *FileVersion) XXX_Size() int {
	return m.ProtoSize()
}
func (m *FileVersion) XXX_DiscardUnknown() {
	xxx_messageInfo_FileVersion.DiscardUnknown(m)
}

var xxx_messageInfo_FileVersion proto.InternalMessageInfo

type VersionList struct {
	RawVersions []FileVersion `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions"`
}

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

var xxx_messageInfo_VersionList proto.InternalMessageInfo

// Must be the same as FileInfo but without the blocks field
type FileInfoTruncated struct {
	Name       string                                              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Size       int64                                               `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	ModifiedS  int64                                               `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modified_s,omitempty"`
	ModifiedBy github_com_syncthing_syncthing_lib_protocol.ShortID `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=github.com/syncthing/syncthing/lib/protocol.ShortID" json:"modified_by"`
	Version    protocol.Vector                                     `protobuf:"bytes,9,opt,name=version,proto3" json:"version"`
	Sequence   int64                                               `protobuf:"varint,10,opt,name=sequence,proto3" json:"sequence,omitempty"`
	// repeated BlockInfo Blocks         = 16
	SymlinkTarget string                `protobuf:"bytes,17,opt,name=symlink_target,json=symlinkTarget,proto3" json:"symlink_target,omitempty"`
	BlocksHash    []byte                `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocks_hash,omitempty"`
	Type          protocol.FileInfoType `protobuf:"varint,2,opt,name=type,proto3,enum=protocol.FileInfoType" json:"type,omitempty"`
	Permissions   uint32                `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions,omitempty"`
	ModifiedNs    int32                 `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3" json:"modified_ns,omitempty"`
	RawBlockSize  int32                 `protobuf:"varint,13,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
	// see bep.proto
	LocalFlags    uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"local_flags,omitempty"`
	VersionHash   []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"version_hash,omitempty"`
	Deleted       bool   `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted,omitempty"`
	RawInvalid    bool   `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid,omitempty"`
	NoPermissions bool   `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"no_permissions,omitempty"`
}

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

var xxx_messageInfo_FileInfoTruncated proto.InternalMessageInfo

// BlockList is the structure used to store block lists
type BlockList struct {
	Blocks []protocol.BlockInfo `protobuf:"bytes,1,rep,name=Blocks,proto3" json:"Blocks"`
}

func (m *BlockList) Reset()         { *m = BlockList{} }
func (m *BlockList) String() string { return proto.CompactTextString(m) }
func (*BlockList) ProtoMessage()    {}
func (*BlockList) Descriptor() ([]byte, []int) {
	return fileDescriptor_e774e8f5f348d14d, []int{3}
}
func (m *BlockList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockList.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 *BlockList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockList.Merge(m, src)
}
func (m *BlockList) XXX_Size() int {
	return m.ProtoSize()
}
func (m *BlockList) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockList.DiscardUnknown(m)
}

var xxx_messageInfo_BlockList proto.InternalMessageInfo

// IndirectionHashesOnly is used to only unmarshal the indirection hashes
// from a FileInfo
type IndirectionHashesOnly struct {
	BlocksHash  []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocks_hash,omitempty"`
	VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"version_hash,omitempty"`
}

func (m *IndirectionHashesOnly) Reset()         { *m = IndirectionHashesOnly{} }
func (m *IndirectionHashesOnly) String() string { return proto.CompactTextString(m) }
func (*IndirectionHashesOnly) ProtoMessage()    {}
func (*IndirectionHashesOnly) Descriptor() ([]byte, []int) {
	return fileDescriptor_e774e8f5f348d14d, []int{4}
}
func (m *IndirectionHashesOnly) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IndirectionHashesOnly) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IndirectionHashesOnly.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 *IndirectionHashesOnly) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndirectionHashesOnly.Merge(m, src)
}
func (m *IndirectionHashesOnly) XXX_Size() int {
	return m.ProtoSize()
}
func (m *IndirectionHashesOnly) XXX_DiscardUnknown() {
	xxx_messageInfo_IndirectionHashesOnly.DiscardUnknown(m)
}

var xxx_messageInfo_IndirectionHashesOnly proto.InternalMessageInfo

// For each folder and device we keep one of these to track the current
// counts and sequence. We also keep one for the global state of the folder.
type Counts struct {
	Files       int32  `protobuf:"varint,1,opt,name=files,proto3" json:"files,omitempty"`
	Directories int32  `protobuf:"varint,2,opt,name=directories,proto3" json:"directories,omitempty"`
	Symlinks    int32  `protobuf:"varint,3,opt,name=symlinks,proto3" json:"symlinks,omitempty"`
	Deleted     int32  `protobuf:"varint,4,opt,name=deleted,proto3" json:"deleted,omitempty"`
	Bytes       int64  `protobuf:"varint,5,opt,name=bytes,proto3" json:"bytes,omitempty"`
	Sequence    int64  `protobuf:"varint,6,opt,name=sequence,proto3" json:"sequence,omitempty"`
	DeviceID    []byte `protobuf:"bytes,17,opt,name=deviceID,proto3" json:"deviceID,omitempty"`
	LocalFlags  uint32 `protobuf:"varint,18,opt,name=localFlags,proto3" json:"localFlags,omitempty"`
}

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

var xxx_messageInfo_Counts proto.InternalMessageInfo

type CountsSet struct {
	Counts  []Counts `protobuf:"bytes,1,rep,name=counts,proto3" json:"counts"`
	Created int64    `protobuf:"varint,2,opt,name=created,proto3" json:"created,omitempty"`
}

func (m *CountsSet) Reset()         { *m = CountsSet{} }
func (m *CountsSet) String() string { return proto.CompactTextString(m) }
func (*CountsSet) ProtoMessage()    {}
func (*CountsSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_e774e8f5f348d14d, []int{6}
}
func (m *CountsSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CountsSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CountsSet.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 *CountsSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountsSet.Merge(m, src)
}
func (m *CountsSet) XXX_Size() int {
	return m.ProtoSize()
}
func (m *CountsSet) XXX_DiscardUnknown() {
	xxx_messageInfo_CountsSet.DiscardUnknown(m)
}

var xxx_messageInfo_CountsSet proto.InternalMessageInfo

type FileVersionDeprecated struct {
	Version protocol.Vector `protobuf:"bytes,1,opt,name=version,proto3" json:"version"`
	Device  []byte          `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"`
	Invalid bool            `protobuf:"varint,3,opt,name=invalid,proto3" json:"invalid,omitempty"`
	Deleted bool            `protobuf:"varint,4,opt,name=deleted,proto3" json:"deleted,omitempty"`
}

func (m *FileVersionDeprecated) Reset()         { *m = FileVersionDeprecated{} }
func (m *FileVersionDeprecated) String() string { return proto.CompactTextString(m) }
func (*FileVersionDeprecated) ProtoMessage()    {}
func (*FileVersionDeprecated) Descriptor() ([]byte, []int) {
	return fileDescriptor_e774e8f5f348d14d, []int{7}
}
func (m *FileVersionDeprecated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FileVersionDeprecated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FileVersionDeprecated.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 *FileVersionDeprecated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileVersionDeprecated.Merge(m, src)
}
func (m *FileVersionDeprecated) XXX_Size() int {
	return m.ProtoSize()
}
func (m *FileVersionDeprecated) XXX_DiscardUnknown() {
	xxx_messageInfo_FileVersionDeprecated.DiscardUnknown(m)
}

var xxx_messageInfo_FileVersionDeprecated proto.InternalMessageInfo

type VersionListDeprecated struct {
	Versions []FileVersionDeprecated `protobuf:"bytes,1,rep,name=versions,proto3" json:"versions"`
}

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

var xxx_messageInfo_VersionListDeprecated proto.InternalMessageInfo

func init() {
	proto.RegisterType((*FileVersion)(nil), "db.FileVersion")
	proto.RegisterType((*VersionList)(nil), "db.VersionList")
	proto.RegisterType((*FileInfoTruncated)(nil), "db.FileInfoTruncated")
	proto.RegisterType((*BlockList)(nil), "db.BlockList")
	proto.RegisterType((*IndirectionHashesOnly)(nil), "db.IndirectionHashesOnly")
	proto.RegisterType((*Counts)(nil), "db.Counts")
	proto.RegisterType((*CountsSet)(nil), "db.CountsSet")
	proto.RegisterType((*FileVersionDeprecated)(nil), "db.FileVersionDeprecated")
	proto.RegisterType((*VersionListDeprecated)(nil), "db.VersionListDeprecated")
}

func init() { proto.RegisterFile("structs.proto", fileDescriptor_e774e8f5f348d14d) }

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

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

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

func (m *FileVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InvalidDevices) > 0 {
		for iNdEx := len(m.InvalidDevices) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.InvalidDevices[iNdEx])
			copy(dAtA[i:], m.InvalidDevices[iNdEx])
			i = encodeVarintStructs(dAtA, i, uint64(len(m.InvalidDevices[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Devices) > 0 {
		for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Devices[iNdEx])
			copy(dAtA[i:], m.Devices[iNdEx])
			i = encodeVarintStructs(dAtA, i, uint64(len(m.Devices[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Deleted {
		i--
		if m.Deleted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStructs(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *FileInfoTruncated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VersionHash) > 0 {
		i -= len(m.VersionHash)
		copy(dAtA[i:], m.VersionHash)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.VersionHash)))
		i--
		dAtA[i] = 0x3e
		i--
		dAtA[i] = 0xca
	}
	if m.LocalFlags != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.LocalFlags))
		i--
		dAtA[i] = 0x3e
		i--
		dAtA[i] = 0xc0
	}
	if len(m.BlocksHash) > 0 {
		i -= len(m.BlocksHash)
		copy(dAtA[i:], m.BlocksHash)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.BlocksHash)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if len(m.SymlinkTarget) > 0 {
		i -= len(m.SymlinkTarget)
		copy(dAtA[i:], m.SymlinkTarget)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.SymlinkTarget)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.RawBlockSize != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.RawBlockSize))
		i--
		dAtA[i] = 0x68
	}
	if m.ModifiedBy != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.ModifiedBy))
		i--
		dAtA[i] = 0x60
	}
	if m.ModifiedNs != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.ModifiedNs))
		i--
		dAtA[i] = 0x58
	}
	if m.Sequence != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x50
	}
	{
		size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStructs(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if m.NoPermissions {
		i--
		if m.NoPermissions {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.RawInvalid {
		i--
		if m.RawInvalid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Deleted {
		i--
		if m.Deleted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.ModifiedS != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.ModifiedS))
		i--
		dAtA[i] = 0x28
	}
	if m.Permissions != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x20
	}
	if m.Size != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Size))
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *IndirectionHashesOnly) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VersionHash) > 0 {
		i -= len(m.VersionHash)
		copy(dAtA[i:], m.VersionHash)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.VersionHash)))
		i--
		dAtA[i] = 0x3e
		i--
		dAtA[i] = 0xca
	}
	if len(m.BlocksHash) > 0 {
		i -= len(m.BlocksHash)
		copy(dAtA[i:], m.BlocksHash)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.BlocksHash)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Counts) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LocalFlags != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.LocalFlags))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if len(m.DeviceID) > 0 {
		i -= len(m.DeviceID)
		copy(dAtA[i:], m.DeviceID)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.DeviceID)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if m.Sequence != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x30
	}
	if m.Bytes != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Bytes))
		i--
		dAtA[i] = 0x28
	}
	if m.Deleted != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Deleted))
		i--
		dAtA[i] = 0x20
	}
	if m.Symlinks != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Symlinks))
		i--
		dAtA[i] = 0x18
	}
	if m.Directories != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Directories))
		i--
		dAtA[i] = 0x10
	}
	if m.Files != 0 {
		i = encodeVarintStructs(dAtA, i, uint64(m.Files))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *FileVersionDeprecated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Deleted {
		i--
		if m.Deleted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Invalid {
		i--
		if m.Invalid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Device) > 0 {
		i -= len(m.Device)
		copy(dAtA[i:], m.Device)
		i = encodeVarintStructs(dAtA, i, uint64(len(m.Device)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintStructs(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func encodeVarintStructs(dAtA []byte, offset int, v uint64) int {
	offset -= sovStructs(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *FileVersion) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Version.ProtoSize()
	n += 1 + l + sovStructs(uint64(l))
	if m.Deleted {
		n += 2
	}
	if len(m.Devices) > 0 {
		for _, b := range m.Devices {
			l = len(b)
			n += 1 + l + sovStructs(uint64(l))
		}
	}
	if len(m.InvalidDevices) > 0 {
		for _, b := range m.InvalidDevices {
			l = len(b)
			n += 1 + l + sovStructs(uint64(l))
		}
	}
	return n
}

func (m *VersionList) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RawVersions) > 0 {
		for _, e := range m.RawVersions {
			l = e.ProtoSize()
			n += 1 + l + sovStructs(uint64(l))
		}
	}
	return n
}

func (m *FileInfoTruncated) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovStructs(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovStructs(uint64(m.Type))
	}
	if m.Size != 0 {
		n += 1 + sovStructs(uint64(m.Size))
	}
	if m.Permissions != 0 {
		n += 1 + sovStructs(uint64(m.Permissions))
	}
	if m.ModifiedS != 0 {
		n += 1 + sovStructs(uint64(m.ModifiedS))
	}
	if m.Deleted {
		n += 2
	}
	if m.RawInvalid {
		n += 2
	}
	if m.NoPermissions {
		n += 2
	}
	l = m.Version.ProtoSize()
	n += 1 + l + sovStructs(uint64(l))
	if m.Sequence != 0 {
		n += 1 + sovStructs(uint64(m.Sequence))
	}
	if m.ModifiedNs != 0 {
		n += 1 + sovStructs(uint64(m.ModifiedNs))
	}
	if m.ModifiedBy != 0 {
		n += 1 + sovStructs(uint64(m.ModifiedBy))
	}
	if m.RawBlockSize != 0 {
		n += 1 + sovStructs(uint64(m.RawBlockSize))
	}
	l = len(m.SymlinkTarget)
	if l > 0 {
		n += 2 + l + sovStructs(uint64(l))
	}
	l = len(m.BlocksHash)
	if l > 0 {
		n += 2 + l + sovStructs(uint64(l))
	}
	if m.LocalFlags != 0 {
		n += 2 + sovStructs(uint64(m.LocalFlags))
	}
	l = len(m.VersionHash)
	if l > 0 {
		n += 2 + l + sovStructs(uint64(l))
	}
	return n
}

func (m *BlockList) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.ProtoSize()
			n += 1 + l + sovStructs(uint64(l))
		}
	}
	return n
}

func (m *IndirectionHashesOnly) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlocksHash)
	if l > 0 {
		n += 2 + l + sovStructs(uint64(l))
	}
	l = len(m.VersionHash)
	if l > 0 {
		n += 2 + l + sovStructs(uint64(l))
	}
	return n
}

func (m *Counts) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Files != 0 {
		n += 1 + sovStructs(uint64(m.Files))
	}
	if m.Directories != 0 {
		n += 1 + sovStructs(uint64(m.Directories))
	}
	if m.Symlinks != 0 {
		n += 1 + sovStructs(uint64(m.Symlinks))
	}
	if m.Deleted != 0 {
		n += 1 + sovStructs(uint64(m.Deleted))
	}
	if m.Bytes != 0 {
		n += 1 + sovStructs(uint64(m.Bytes))
	}
	if m.Sequence != 0 {
		n += 1 + sovStructs(uint64(m.Sequence))
	}
	l = len(m.DeviceID)
	if l > 0 {
		n += 2 + l + sovStructs(uint64(l))
	}
	if m.LocalFlags != 0 {
		n += 2 + sovStructs(uint64(m.LocalFlags))
	}
	return n
}

func (m *CountsSet) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Counts) > 0 {
		for _, e := range m.Counts {
			l = e.ProtoSize()
			n += 1 + l + sovStructs(uint64(l))
		}
	}
	if m.Created != 0 {
		n += 1 + sovStructs(uint64(m.Created))
	}
	return n
}

func (m *FileVersionDeprecated) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Version.ProtoSize()
	n += 1 + l + sovStructs(uint64(l))
	l = len(m.Device)
	if l > 0 {
		n += 1 + l + sovStructs(uint64(l))
	}
	if m.Invalid {
		n += 2
	}
	if m.Deleted {
		n += 2
	}
	return n
}

func (m *VersionListDeprecated) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Versions) > 0 {
		for _, e := range m.Versions {
			l = e.ProtoSize()
			n += 1 + l + sovStructs(uint64(l))
		}
	}
	return n
}

func sovStructs(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozStructs(x uint64) (n int) {
	return sovStructs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *FileVersion) 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 ErrIntOverflowStructs
			}
			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: FileVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileVersion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Deleted = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Devices = append(m.Devices, make([]byte, postIndex-iNdEx))
			copy(m.Devices[len(m.Devices)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InvalidDevices", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InvalidDevices = append(m.InvalidDevices, make([]byte, postIndex-iNdEx))
			copy(m.InvalidDevices[len(m.InvalidDevices)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileInfoTruncated) 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 ErrIntOverflowStructs
			}
			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: FileInfoTruncated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileInfoTruncated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				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 ErrInvalidLengthStructs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= protocol.FileInfoType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedS", wireType)
			}
			m.ModifiedS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModifiedS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Deleted = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawInvalid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RawInvalid = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoPermissions", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoPermissions = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedNs", wireType)
			}
			m.ModifiedNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModifiedNs |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModifiedBy", wireType)
			}
			m.ModifiedBy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ModifiedBy |= github_com_syncthing_syncthing_lib_protocol.ShortID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBlockSize", wireType)
			}
			m.RawBlockSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RawBlockSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SymlinkTarget", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				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 ErrInvalidLengthStructs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SymlinkTarget = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlocksHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlocksHash = append(m.BlocksHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BlocksHash == nil {
				m.BlocksHash = []byte{}
			}
			iNdEx = postIndex
		case 1000:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalFlags", wireType)
			}
			m.LocalFlags = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LocalFlags |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 1001:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VersionHash = append(m.VersionHash[:0], dAtA[iNdEx:postIndex]...)
			if m.VersionHash == nil {
				m.VersionHash = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Counts) 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 ErrIntOverflowStructs
			}
			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: Counts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Counts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType)
			}
			m.Files = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Files |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Directories", wireType)
			}
			m.Directories = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Directories |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symlinks", wireType)
			}
			m.Symlinks = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Symlinks |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
			}
			m.Deleted = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Deleted |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType)
			}
			m.Bytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceID = append(m.DeviceID[:0], dAtA[iNdEx:postIndex]...)
			if m.DeviceID == nil {
				m.DeviceID = []byte{}
			}
			iNdEx = postIndex
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LocalFlags", wireType)
			}
			m.LocalFlags = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LocalFlags |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FileVersionDeprecated) 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 ErrIntOverflowStructs
			}
			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: FileVersionDeprecated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FileVersionDeprecated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructs
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStructs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Device = append(m.Device[:0], dAtA[iNdEx:postIndex]...)
			if m.Device == nil {
				m.Device = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Invalid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Invalid = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Deleted = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipStructs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthStructs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthStructs        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowStructs          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupStructs = fmt.Errorf("proto: unexpected end of group")
)