Add indirection for large version vectors. (#6376)

This adds indirection of large version vectors in the same manner as we
already to block lists. The effect is the same: less duplicated data in
some situations.

To mitigate the impact for when this indirection
wouldn't be needed I've added an indirection cutoff for both blocks and
the new version vector stuff: we don't do the indirection at all for
small block lists or small version vectors, instead storing it directly
like we used to do. This is faster for small files and small setups.

cmd/stindex/idxck.go

@@ -43,7 +43,9 @@ func idxck(ldb backend.Backend) (success bool) {
 	sequences := make(map[sequenceKey]string)
 	needs := make(map[globalKey]struct{})
 	blocklists := make(map[string]struct{})
+	versions := make(map[string]protocol.Vector)
 	usedBlocklists := make(map[string]struct{})
+	usedVersions := make(map[string]struct{})
 	var localDeviceKey uint32
 	success = true
 
@@ -106,6 +108,16 @@ func idxck(ldb backend.Backend) (success bool) {
 		case db.KeyTypeBlockList:
 			hash := string(key[1:])
 			blocklists[hash] = struct{}{}
+
+		case db.KeyTypeVersion:
+			hash := string(key[1:])
+			var v protocol.Vector
+			if err := v.Unmarshal(it.Value()); err != nil {
+				fmt.Println("Unable to unmarshal Vector:", err)
+				success = false
+				continue
+			}
+			versions[hash] = v
 		}
 	}
 
@@ -157,6 +169,23 @@ func idxck(ldb backend.Backend) (success bool) {
 				usedBlocklists[key] = struct{}{}
 			}
 		}
+
+		if fi.VersionHash != nil {
+			key := string(fi.VersionHash)
+			if _, ok := versions[key]; !ok {
+				fmt.Printf("Missing version vector for file %q, version hash %x\n", fi.Name, fi.VersionHash)
+				success = false
+			} else {
+				usedVersions[key] = struct{}{}
+			}
+		}
+
+		_, ok := globals[globalKey{fk.folder, fk.name}]
+		if !ok {
+			fmt.Printf("Missing global for file %q\n", fi.Name)
+			success = false
+			continue
+		}
 	}
 
 	// Aggregate the ranges of missing sequence entries, print them
@@ -201,7 +230,12 @@ func idxck(ldb backend.Backend) (success bool) {
 				fmt.Printf("VersionList %q, folder %q, entry %d refers to unknown FileInfo\n", gk.name, folder, i)
 				success = false
 			}
-			if !fi.Version.Equal(fv.Version) {
+
+			fiv := fi.Version
+			if fi.VersionHash != nil {
+				fiv = versions[string(fi.VersionHash)]
+			}
+			if !fiv.Equal(fv.Version) {
 				fmt.Printf("VersionList %q, folder %q, entry %d, FileInfo version mismatch, %v (VersionList) != %v (FileInfo)\n", gk.name, folder, i, fv.Version, fi.Version)
 				success = false
 			}
@@ -277,6 +311,9 @@ func idxck(ldb backend.Backend) (success bool) {
 	if d := len(blocklists) - len(usedBlocklists); d > 0 {
 		fmt.Printf("%d block list entries out of %d needs GC\n", d, len(blocklists))
 	}
+	if d := len(versions) - len(usedVersions); d > 0 {
+		fmt.Printf("%d version entries out of %d needs GC\n", d, len(versions))
+	}
 
 	return
 }

lib/db/keyer.go

@@ -65,6 +65,9 @@ const (
 
 	// KeyTypeBlockListMap <int32 folder ID> <block list hash> <file name> = <nothing>
 	KeyTypeBlockListMap = 14
+
+	// KeyTypeVersion <version hash> = Vector
+	KeyTypeVersion = 15
 )
 
 type keyer interface {
@@ -104,6 +107,9 @@ type keyer interface {
 
 	// Block lists
 	GenerateBlockListKey(key []byte, hash []byte) blockListKey
+
+	// Version vectors
+	GenerateVersionKey(key []byte, hash []byte) versionKey
 }
 
 // defaultKeyer implements our key scheme. It needs folder and device
@@ -328,7 +334,20 @@ func (k defaultKeyer) GenerateBlockListKey(key []byte, hash []byte) blockListKey
 	return key
 }
 
-func (k blockListKey) BlocksHash() []byte {
+func (k blockListKey) Hash() []byte {
+	return k[keyPrefixLen:]
+}
+
+type versionKey []byte
+
+func (k defaultKeyer) GenerateVersionKey(key []byte, hash []byte) versionKey {
+	key = resize(key, keyPrefixLen+len(hash))
+	key[0] = KeyTypeVersion
+	copy(key[keyPrefixLen:], hash)
+	return key
+}
+
+func (k versionKey) Hash() []byte {
 	return k[keyPrefixLen:]
 }
 

lib/db/lowlevel.go

@@ -15,6 +15,7 @@ import (
 	"github.com/greatroar/blobloom"
 	"github.com/syncthing/syncthing/lib/db/backend"
 	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syncthing/syncthing/lib/sha256"
 	"github.com/syncthing/syncthing/lib/sync"
 	"github.com/syncthing/syncthing/lib/util"
 	"github.com/thejerf/suture"
@@ -34,6 +35,8 @@ const (
 
 	// Use indirection for the block list when it exceeds this many entries
 	blocksIndirectionCutoff = 3
+	// Use indirection for the version vector when it exceeds this many entries
+	versionIndirectionCutoff = 10
 
 	recheckDefaultInterval = 30 * 24 * time.Hour
 )
@@ -630,11 +633,8 @@ func (db *Lowlevel) gcIndirect(ctx context.Context) error {
 	if db.gcKeyCount > capacity {
 		capacity = db.gcKeyCount
 	}
-	blockFilter := blobloom.NewOptimized(blobloom.Config{
-		Capacity: uint64(capacity),
-		FPRate:   indirectGCBloomFalsePositiveRate,
-		MaxBits:  8 * indirectGCBloomMaxBytes,
-	})
+	blockFilter := newBloomFilter(capacity)
+	versionFilter := newBloomFilter(capacity)
 
 	// Iterate the FileInfos, unmarshal the block and version hashes and
 	// add them to the filter.
@@ -651,12 +651,15 @@ func (db *Lowlevel) gcIndirect(ctx context.Context) error {
 		default:
 		}
 
-		var bl BlocksHashOnly
-		if err := bl.Unmarshal(it.Value()); err != nil {
+		var hashes IndirectionHashesOnly
+		if err := hashes.Unmarshal(it.Value()); err != nil {
 			return err
 		}
-		if len(bl.BlocksHash) > 0 {
-			blockFilter.Add(bloomHash(bl.BlocksHash))
+		if len(hashes.BlocksHash) > 0 {
+			blockFilter.Add(bloomHash(hashes.BlocksHash))
+		}
+		if len(hashes.VersionHash) > 0 {
+			versionFilter.Add(bloomHash(hashes.VersionHash))
 		}
 	}
 	it.Release()
@@ -681,7 +684,7 @@ func (db *Lowlevel) gcIndirect(ctx context.Context) error {
 		}
 
 		key := blockListKey(it.Key())
-		if blockFilter.Has(bloomHash(key.BlocksHash())) {
+		if blockFilter.Has(bloomHash(key.Hash())) {
 			matchedBlocks++
 			continue
 		}
@@ -694,8 +697,40 @@ func (db *Lowlevel) gcIndirect(ctx context.Context) error {
 		return err
 	}
 
+	// Iterate over version lists, removing keys with hashes that don't match
+	// the filter.
+
+	it, err = db.NewPrefixIterator([]byte{KeyTypeVersion})
+	if err != nil {
+		return err
+	}
+	matchedVersions := 0
+	for it.Next() {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+
+		key := versionKey(it.Key())
+		if versionFilter.Has(bloomHash(key.Hash())) {
+			matchedVersions++
+			continue
+		}
+		if err := t.Delete(key); err != nil {
+			return err
+		}
+	}
+	it.Release()
+	if err := it.Error(); err != nil {
+		return err
+	}
+
 	// Remember the number of unique keys we kept until the next pass.
 	db.gcKeyCount = matchedBlocks
+	if matchedVersions > matchedBlocks {
+		db.gcKeyCount = matchedVersions
+	}
 
 	if err := t.Commit(); err != nil {
 		return err
@@ -704,9 +739,20 @@ func (db *Lowlevel) gcIndirect(ctx context.Context) error {
 	return db.Compact()
 }
 
+func newBloomFilter(capacity int) *blobloom.Filter {
+	return blobloom.NewOptimized(blobloom.Config{
+		Capacity: uint64(capacity),
+		FPRate:   indirectGCBloomFalsePositiveRate,
+		MaxBits:  8 * indirectGCBloomMaxBytes,
+	})
+}
+
 // Hash function for the bloomfilter: first eight bytes of the SHA-256.
 // Big or little-endian makes no difference, as long as we're consistent.
 func bloomHash(key []byte) uint64 {
+	if len(key) != sha256.Size {
+		panic("bug: bloomHash passed something not a SHA256 hash")
+	}
 	return binary.BigEndian.Uint64(key)
 }
 

lib/db/schemaupdater.go

@@ -23,9 +23,10 @@ import (
 //   7: v0.14.53
 //   8-9: v1.4.0
 //   10-11: v1.6.0
+//   12: v1.7.0
 const (
-	dbVersion             = 11
-	dbMinSyncthingVersion = "v1.6.0"
+	dbVersion             = 12
+	dbMinSyncthingVersion = "v1.7.0"
 )
 
 type databaseDowngradeError struct {
@@ -88,6 +89,7 @@ func (db *schemaUpdater) updateSchema() error {
 		{9, db.updateSchemaTo9},
 		{10, db.updateSchemaTo10},
 		{11, db.updateSchemaTo11},
+		{12, db.updateSchemaTo12},
 	}
 
 	for _, m := range migrations {
@@ -453,7 +455,6 @@ func (db *schemaUpdater) updateSchema6to7(_ int) error {
 
 func (db *schemaUpdater) updateSchemaTo9(prev int) error {
 	// Loads and rewrites all files with blocks, to deduplicate block lists.
-	// Checks for missing or incorrect sequence entries and rewrites those.
 
 	t, err := db.newReadWriteTransaction()
 	if err != nil {
@@ -461,6 +462,16 @@ func (db *schemaUpdater) updateSchemaTo9(prev int) error {
 	}
 	defer t.close()
 
+	if err := db.rewriteFiles(t); err != nil {
+		return err
+	}
+
+	db.recordTime(indirectGCTimeKey)
+
+	return t.Commit()
+}
+
+func (db *schemaUpdater) rewriteFiles(t readWriteTransaction) error {
 	it, err := t.NewPrefixIterator([]byte{KeyTypeDevice})
 	if err != nil {
 		return err
@@ -491,13 +502,7 @@ func (db *schemaUpdater) updateSchemaTo9(prev int) error {
 		}
 	}
 	it.Release()
-	if err := it.Error(); err != nil {
-		return err
-	}
-
-	db.recordTime(indirectGCTimeKey)
-
-	return t.Commit()
+	return it.Error()
 }
 
 func (db *schemaUpdater) updateSchemaTo10(_ int) error {
@@ -610,3 +615,19 @@ func (db *schemaUpdater) updateSchemaTo11(_ int) error {
 	}
 	return t.Commit()
 }
+
+func (db *schemaUpdater) updateSchemaTo12(_ int) error {
+	// Loads and rewrites all files, to deduplicate version vectors.
+
+	t, err := db.newReadWriteTransaction()
+	if err != nil {
+		return err
+	}
+	defer t.close()
+
+	if err := db.rewriteFiles(t); err != nil {
+		return err
+	}
+
+	return t.Commit()
+}

lib/db/structs.pb.go

@@ -118,6 +118,7 @@ type FileInfoTruncated struct {
 	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"`
@@ -193,23 +194,25 @@ func (m *BlockList) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_BlockList proto.InternalMessageInfo
 
-// BlocksHashOnly is used to only unmarshal the block list hash from a FileInfo
-type BlocksHashOnly struct {
-	BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocks_hash,omitempty"`
+// 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 *BlocksHashOnly) Reset()         { *m = BlocksHashOnly{} }
-func (m *BlocksHashOnly) String() string { return proto.CompactTextString(m) }
-func (*BlocksHashOnly) ProtoMessage()    {}
-func (*BlocksHashOnly) Descriptor() ([]byte, []int) {
+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 *BlocksHashOnly) XXX_Unmarshal(b []byte) error {
+func (m *IndirectionHashesOnly) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *BlocksHashOnly) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *IndirectionHashesOnly) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_BlocksHashOnly.Marshal(b, m, deterministic)
+		return xxx_messageInfo_IndirectionHashesOnly.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -219,17 +222,17 @@ func (m *BlocksHashOnly) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
-func (m *BlocksHashOnly) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_BlocksHashOnly.Merge(m, src)
+func (m *IndirectionHashesOnly) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndirectionHashesOnly.Merge(m, src)
 }
-func (m *BlocksHashOnly) XXX_Size() int {
+func (m *IndirectionHashesOnly) XXX_Size() int {
 	return m.ProtoSize()
 }
-func (m *BlocksHashOnly) XXX_DiscardUnknown() {
-	xxx_messageInfo_BlocksHashOnly.DiscardUnknown(m)
+func (m *IndirectionHashesOnly) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndirectionHashesOnly.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_BlocksHashOnly proto.InternalMessageInfo
+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.
@@ -320,7 +323,7 @@ func init() {
 	proto.RegisterType((*VersionList)(nil), "db.VersionList")
 	proto.RegisterType((*FileInfoTruncated)(nil), "db.FileInfoTruncated")
 	proto.RegisterType((*BlockList)(nil), "db.BlockList")
-	proto.RegisterType((*BlocksHashOnly)(nil), "db.BlocksHashOnly")
+	proto.RegisterType((*IndirectionHashesOnly)(nil), "db.IndirectionHashesOnly")
 	proto.RegisterType((*Counts)(nil), "db.Counts")
 	proto.RegisterType((*CountsSet)(nil), "db.CountsSet")
 }
@@ -328,54 +331,56 @@ func init() {
 func init() { proto.RegisterFile("structs.proto", fileDescriptor_e774e8f5f348d14d) }
 
 var fileDescriptor_e774e8f5f348d14d = []byte{
-	// 747 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xbf, 0x8f, 0xe2, 0x46,
-	0x14, 0xc6, 0x07, 0x66, 0xe1, 0x19, 0xc8, 0xdd, 0xe4, 0xb4, 0xb2, 0x90, 0x62, 0x2c, 0xa2, 0x93,
-	0xac, 0x14, 0x90, 0xdb, 0xeb, 0x12, 0x29, 0x85, 0x73, 0x5a, 0x05, 0x29, 0xca, 0x45, 0xc3, 0xe9,
-	0xaa, 0x48, 0xc8, 0x3f, 0x06, 0x18, 0xad, 0xf1, 0x10, 0xcf, 0xb0, 0x2b, 0x6f, 0x97, 0x3a, 0x4d,
-	0xca, 0x94, 0xfb, 0xe7, 0x6c, 0xb9, 0x65, 0x94, 0x02, 0x25, 0x90, 0x22, 0x7f, 0x46, 0x34, 0x33,
-	0xb6, 0xf1, 0x6e, 0x93, 0xeb, 0xde, 0xf7, 0xbd, 0x07, 0xef, 0xc7, 0xf7, 0x79, 0xa0, 0xcf, 0x45,
-	0xb6, 0x8b, 0x04, 0x9f, 0x6c, 0x33, 0x26, 0x18, 0x7a, 0x16, 0x87, 0xc3, 0xcf, 0x33, 0xb2, 0x65,
-	0x7c, 0xaa, 0x88, 0x70, 0xb7, 0x9c, 0xae, 0xd8, 0x8a, 0x29, 0xa0, 0x22, 0x5d, 0x38, 0x3c, 0x4f,
-	0x68, 0xa8, 0x4b, 0x22, 0x96, 0x4c, 0x43, 0xb2, 0xd5, 0xfc, 0xf8, 0x57, 0x03, 0xac, 0x4b, 0x9a,
-	0x90, 0x0f, 0x24, 0xe3, 0x94, 0xa5, 0xe8, 0x4b, 0x38, 0xbb, 0xd6, 0xa1, 0x6d, 0xb8, 0x86, 0x67,
-	0x5d, 0x3c, 0x9f, 0x94, 0xbf, 0x9a, 0x7c, 0x20, 0x91, 0x60, 0x99, 0xdf, 0xba, 0xdf, 0x8f, 0x1a,
-	0xb8, 0x2c, 0x43, 0xe7, 0xd0, 0x8e, 0xc9, 0x35, 0x8d, 0x88, 0xfd, 0xcc, 0x35, 0xbc, 0x1e, 0x2e,
-	0x10, 0xb2, 0xe1, 0x8c, 0xa6, 0xd7, 0x41, 0x42, 0x63, 0xbb, 0xe9, 0x1a, 0x5e, 0x07, 0x97, 0x50,
-	0x66, 0x62, 0x92, 0x10, 0x41, 0x62, 0xbb, 0xa5, 0x33, 0x05, 0x1c, 0x5f, 0x82, 0x55, 0x0c, 0xf2,
-	0x3d, 0xe5, 0x02, 0xbd, 0x86, 0x4e, 0xd1, 0x85, 0xdb, 0x86, 0xdb, 0xf4, 0xac, 0x8b, 0x4f, 0x26,
-	0x71, 0x38, 0xa9, 0xcd, 0x5b, 0x0c, 0x53, 0x95, 0x7d, 0xd5, 0xfa, 0xfd, 0x6e, 0xd4, 0x18, 0xff,
-	0x62, 0xc2, 0x0b, 0x59, 0x35, 0x4b, 0x97, 0xec, 0x7d, 0xb6, 0x4b, 0xa3, 0x40, 0x90, 0x18, 0x21,
-	0x68, 0xa5, 0xc1, 0x86, 0xa8, 0xc5, 0xba, 0x58, 0xc5, 0x92, 0xe3, 0xf4, 0x96, 0xa8, 0x11, 0x9b,
-	0x58, 0xc5, 0xe8, 0x33, 0x80, 0x0d, 0x8b, 0xe9, 0x92, 0x92, 0x78, 0xc1, 0x6d, 0x53, 0x65, 0xba,
-	0x25, 0x33, 0x47, 0x3f, 0x81, 0x55, 0xa5, 0xc3, 0xdc, 0xee, 0xb9, 0x86, 0xd7, 0xf2, 0xbf, 0x96,
-	0x73, 0xfc, 0xb9, 0x1f, 0xbd, 0x59, 0x51, 0xb1, 0xde, 0x85, 0x93, 0x88, 0x6d, 0xa6, 0x3c, 0x4f,
-	0x23, 0xb1, 0xa6, 0xe9, 0xaa, 0x16, 0xd5, 0x65, 0x98, 0xcc, 0xd7, 0x2c, 0x13, 0xb3, 0xb7, 0xb8,
-	0x6a, 0xe7, 0xe7, 0x75, 0x01, 0xba, 0x1f, 0x27, 0xc0, 0x10, 0x3a, 0x9c, 0xfc, 0xbc, 0x23, 0x69,
-	0x44, 0x6c, 0x50, 0xc3, 0x56, 0x18, 0xbd, 0x82, 0x01, 0xcf, 0x37, 0x09, 0x4d, 0xaf, 0x16, 0x22,
-	0xc8, 0x56, 0x44, 0xd8, 0x2f, 0xd4, 0xf2, 0xfd, 0x82, 0x7d, 0xaf, 0x48, 0x34, 0x02, 0x2b, 0x4c,
-	0x58, 0x74, 0xc5, 0x17, 0xeb, 0x80, 0xaf, 0x6d, 0xa4, 0x84, 0x04, 0x4d, 0x7d, 0x17, 0xf0, 0x35,
-	0xfa, 0x02, 0x5a, 0x22, 0xdf, 0x6a, 0x89, 0x07, 0x17, 0xe7, 0xa7, 0x91, 0xaa, 0x2b, 0xe7, 0x5b,
-	0x82, 0x55, 0x0d, 0x72, 0xc1, 0xda, 0x92, 0x6c, 0x43, 0xb9, 0x16, 0x4e, 0x4a, 0xdc, 0xc7, 0x75,
-	0x4a, 0xb6, 0xab, 0x2e, 0x98, 0x72, 0xdb, 0x72, 0x0d, 0xcf, 0x3c, 0x1d, 0xe1, 0x07, 0x8e, 0xa6,
-	0xa0, 0x9b, 0x2f, 0x94, 0x36, 0x7d, 0x99, 0xf7, 0x9f, 0x1f, 0xf6, 0xa3, 0x1e, 0x0e, 0x6e, 0x7c,
-	0x99, 0x98, 0xd3, 0x5b, 0x82, 0xbb, 0x61, 0x19, 0xca, 0x9e, 0x09, 0x8b, 0x82, 0x64, 0xb1, 0x4c,
-	0x82, 0x15, 0xb7, 0xff, 0x3d, 0x53, 0x4d, 0x41, 0x71, 0x97, 0x92, 0xaa, 0x9b, 0xae, 0xfd, 0xc8,
-	0x74, 0xc8, 0x3b, 0x19, 0x55, 0xfe, 0xac, 0xe3, 0x0f, 0x0e, 0xfb, 0x11, 0xe0, 0xe0, 0x66, 0xa6,
-	0xd9, 0x93, 0x71, 0x5f, 0xc1, 0x20, 0x65, 0x8b, 0xfa, 0x72, 0x1d, 0xf5, 0x57, 0xfd, 0x94, 0xfd,
-	0x78, 0x22, 0x0b, 0x0f, 0x7e, 0x03, 0x5d, 0x35, 0x6a, 0xe1, 0xe4, 0xb6, 0x02, 0xa5, 0x8f, 0x3f,
-	0x3d, 0x5d, 0x50, 0xf1, 0xf2, 0x84, 0x85, 0xae, 0x45, 0xe1, 0xf8, 0x35, 0x0c, 0xfc, 0x4a, 0x80,
-	0x77, 0x69, 0x92, 0xff, 0xaf, 0x4a, 0xe3, 0x7f, 0x0c, 0x68, 0x7f, 0xcb, 0x76, 0xa9, 0xe0, 0xe8,
-	0x25, 0x98, 0x4b, 0x9a, 0x10, 0xae, 0xcc, 0x6e, 0x62, 0x0d, 0xe4, 0x99, 0x62, 0x9a, 0x29, 0x17,
-	0x51, 0xc2, 0x95, 0x9a, 0x26, 0xae, 0x53, 0xca, 0x4c, 0xda, 0x1a, 0x5c, 0x7d, 0x13, 0x26, 0xae,
-	0xf0, 0xd3, 0xef, 0xd6, 0x3c, 0x9d, 0xf0, 0x25, 0x98, 0x61, 0x2e, 0x48, 0xf9, 0xb1, 0x68, 0xf0,
-	0xc8, 0x98, 0xed, 0x27, 0xc6, 0x1c, 0x42, 0x47, 0xbf, 0x13, 0xb3, 0xb7, 0xca, 0x92, 0x3d, 0x5c,
-	0x61, 0xe4, 0x40, 0x4d, 0x38, 0xb5, 0xe6, 0x23, 0x29, 0xc7, 0xef, 0xa0, 0xab, 0xb7, 0x9c, 0x13,
-	0x81, 0x3c, 0x68, 0x47, 0x0a, 0x14, 0x97, 0x05, 0xf9, 0x42, 0xe8, 0x74, 0x79, 0x50, 0x9d, 0x97,
-	0xe3, 0x47, 0x19, 0x91, 0x2f, 0x81, 0x5a, 0xbc, 0x89, 0x4b, 0xe8, 0xbb, 0xf7, 0x7f, 0x3b, 0x8d,
-	0xfb, 0x83, 0x63, 0x3c, 0x1c, 0x1c, 0xe3, 0xaf, 0x83, 0xd3, 0xf8, 0xed, 0xe8, 0x34, 0xee, 0x8e,
-	0x8e, 0xf1, 0x70, 0x74, 0x1a, 0x7f, 0x1c, 0x9d, 0x46, 0xd8, 0x56, 0x72, 0xbd, 0xf9, 0x2f, 0x00,
-	0x00, 0xff, 0xff, 0x8a, 0x67, 0x08, 0x85, 0x7f, 0x05, 0x00, 0x00,
+	// 774 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x8f, 0xe3, 0x44,
+	0x10, 0x8d, 0x37, 0x71, 0x3e, 0xca, 0x49, 0xd8, 0x6d, 0x96, 0x91, 0x15, 0x09, 0xc7, 0x0a, 0x5a,
+	0xc9, 0xe2, 0x90, 0xc0, 0xec, 0x0d, 0x24, 0x0e, 0x61, 0x35, 0x22, 0x12, 0x62, 0x51, 0x67, 0xb5,
+	0xa7, 0x95, 0x22, 0x7f, 0x74, 0x92, 0xd6, 0x38, 0xee, 0xe0, 0xee, 0xcc, 0xc8, 0xf3, 0x17, 0xb8,
+	0x70, 0xe4, 0x38, 0x17, 0xfe, 0xcb, 0x1c, 0xe7, 0x88, 0x38, 0x44, 0x90, 0x70, 0x80, 0x7f, 0x81,
+	0xba, 0xdb, 0x76, 0x3c, 0x73, 0x61, 0x6e, 0x55, 0xaf, 0x2a, 0xa9, 0xaa, 0xf7, 0x9e, 0x1b, 0x7a,
+	0x5c, 0xa4, 0xbb, 0x50, 0xf0, 0xf1, 0x36, 0x65, 0x82, 0xa1, 0x67, 0x51, 0x30, 0xf8, 0x2c, 0x25,
+	0x5b, 0xc6, 0x27, 0x0a, 0x08, 0x76, 0xcb, 0xc9, 0x8a, 0xad, 0x98, 0x4a, 0x54, 0xa4, 0x1b, 0x07,
+	0x67, 0x31, 0x0d, 0x74, 0x4b, 0xc8, 0xe2, 0x49, 0x40, 0xb6, 0x1a, 0x1f, 0xfd, 0x6c, 0x80, 0x75,
+	0x41, 0x63, 0xf2, 0x9e, 0xa4, 0x9c, 0xb2, 0x04, 0x7d, 0x01, 0xad, 0x2b, 0x1d, 0xda, 0x86, 0x6b,
+	0x78, 0xd6, 0xf9, 0xf3, 0x71, 0xf1, 0xab, 0xf1, 0x7b, 0x12, 0x0a, 0x96, 0x4e, 0x1b, 0x77, 0xfb,
+	0x61, 0x0d, 0x17, 0x6d, 0xe8, 0x0c, 0x9a, 0x11, 0xb9, 0xa2, 0x21, 0xb1, 0x9f, 0xb9, 0x86, 0xd7,
+	0xc5, 0x79, 0x86, 0x6c, 0x68, 0xd1, 0xe4, 0xca, 0x8f, 0x69, 0x64, 0xd7, 0x5d, 0xc3, 0x6b, 0xe3,
+	0x22, 0x95, 0x95, 0x88, 0xc4, 0x44, 0x90, 0xc8, 0x6e, 0xe8, 0x4a, 0x9e, 0x8e, 0x2e, 0xc0, 0xca,
+	0x17, 0xf9, 0x9e, 0x72, 0x81, 0xbe, 0x84, 0x76, 0x3e, 0x85, 0xdb, 0x86, 0x5b, 0xf7, 0xac, 0xf3,
+	0x8f, 0xc6, 0x51, 0x30, 0xae, 0xec, 0x9b, 0x2f, 0x53, 0xb6, 0x7d, 0xd5, 0xf8, 0xf5, 0x76, 0x58,
+	0x1b, 0xfd, 0x66, 0xc2, 0x0b, 0xd9, 0x35, 0x4b, 0x96, 0xec, 0x5d, 0xba, 0x4b, 0x42, 0x5f, 0x90,
+	0x08, 0x21, 0x68, 0x24, 0xfe, 0x86, 0xa8, 0xc3, 0x3a, 0x58, 0xc5, 0x12, 0xe3, 0xf4, 0x86, 0xa8,
+	0x15, 0xeb, 0x58, 0xc5, 0xe8, 0x53, 0x80, 0x0d, 0x8b, 0xe8, 0x92, 0x92, 0x68, 0xc1, 0x6d, 0x53,
+	0x55, 0x3a, 0x05, 0x32, 0x47, 0x1f, 0xc0, 0x2a, 0xcb, 0x41, 0x66, 0x77, 0x5d, 0xc3, 0x6b, 0x4c,
+	0xbf, 0x96, 0x7b, 0xfc, 0xb1, 0x1f, 0xbe, 0x5e, 0x51, 0xb1, 0xde, 0x05, 0xe3, 0x90, 0x6d, 0x26,
+	0x3c, 0x4b, 0x42, 0xb1, 0xa6, 0xc9, 0xaa, 0x12, 0x55, 0x65, 0x18, 0xcf, 0xd7, 0x2c, 0x15, 0xb3,
+	0x37, 0xb8, 0x1c, 0x37, 0xcd, 0xaa, 0x02, 0x74, 0x9e, 0x26, 0xc0, 0x00, 0xda, 0x9c, 0xfc, 0xb4,
+	0x23, 0x49, 0x48, 0x6c, 0x50, 0xcb, 0x96, 0x39, 0x7a, 0x05, 0x7d, 0x9e, 0x6d, 0x62, 0x9a, 0x5c,
+	0x2e, 0x84, 0x9f, 0xae, 0x88, 0xb0, 0x5f, 0xa8, 0xe3, 0x7b, 0x39, 0xfa, 0x4e, 0x81, 0x68, 0x08,
+	0x56, 0x10, 0xb3, 0xf0, 0x92, 0x2f, 0xd6, 0x3e, 0x5f, 0xdb, 0x48, 0x09, 0x09, 0x1a, 0xfa, 0xce,
+	0xe7, 0x6b, 0xf4, 0x39, 0x34, 0x44, 0xb6, 0xd5, 0x12, 0xf7, 0xcf, 0xcf, 0x4e, 0x2b, 0x95, 0x2c,
+	0x67, 0x5b, 0x82, 0x55, 0x0f, 0x72, 0xc1, 0xda, 0x92, 0x74, 0x43, 0xb9, 0x16, 0x4e, 0x4a, 0xdc,
+	0xc3, 0x55, 0x48, 0x8e, 0x2b, 0x19, 0x4c, 0xb8, 0x6d, 0xb9, 0x86, 0x67, 0x9e, 0x48, 0xf8, 0x81,
+	0xa3, 0x09, 0xe8, 0xe1, 0x0b, 0xa5, 0x4d, 0x4f, 0xd6, 0xa7, 0xcf, 0x0f, 0xfb, 0x61, 0x17, 0xfb,
+	0xd7, 0x53, 0x59, 0x98, 0xd3, 0x1b, 0x82, 0x3b, 0x41, 0x11, 0xca, 0x99, 0x31, 0x0b, 0xfd, 0x78,
+	0xb1, 0x8c, 0xfd, 0x15, 0xb7, 0xff, 0x69, 0xa9, 0xa1, 0xa0, 0xb0, 0x0b, 0x09, 0xa1, 0x11, 0x74,
+	0x73, 0xc2, 0xf4, 0x8d, 0xff, 0xb6, 0xd4, 0x91, 0x56, 0x0e, 0xaa, 0x2b, 0x2b, 0xc6, 0x6c, 0x3e,
+	0x30, 0x26, 0xf2, 0x4e, 0x66, 0x96, 0xbf, 0x6b, 0x4f, 0xfb, 0x87, 0xfd, 0x10, 0xb0, 0x7f, 0x3d,
+	0xd3, 0xe8, 0xc9, 0xdc, 0xaf, 0xa0, 0x9f, 0xb0, 0x45, 0x95, 0x80, 0xb6, 0xfa, 0xab, 0x5e, 0xc2,
+	0x7e, 0x3c, 0x81, 0xb9, 0x4f, 0xbf, 0x81, 0x8e, 0x3a, 0x27, 0x77, 0x7b, 0x53, 0x25, 0x85, 0xd7,
+	0x3f, 0x3e, 0xb1, 0xac, 0x70, 0x49, 0x73, 0xae, 0x7d, 0xde, 0x38, 0xfa, 0x00, 0x9f, 0xcc, 0x92,
+	0x88, 0xa6, 0x24, 0x14, 0xf9, 0x0d, 0x84, 0xbf, 0x4d, 0xe2, 0xec, 0xff, 0x05, 0x7d, 0x02, 0x1d,
+	0xa3, 0xbf, 0x0d, 0x68, 0x7e, 0xcb, 0x76, 0x89, 0xe0, 0xe8, 0x25, 0x98, 0x4b, 0x1a, 0x13, 0xae,
+	0xbe, 0x1d, 0x13, 0xeb, 0x44, 0xb2, 0xae, 0x87, 0xb3, 0x94, 0x12, 0xae, 0xcc, 0x61, 0xe2, 0x2a,
+	0xa4, 0xbc, 0xa9, 0x9d, 0xc6, 0xd5, 0x27, 0x66, 0xe2, 0x32, 0x7f, 0xfc, 0x0c, 0x98, 0x27, 0xb6,
+	0x5f, 0x82, 0x19, 0x64, 0x82, 0x14, 0xdf, 0x9e, 0x4e, 0x1e, 0xf8, 0xbc, 0xf9, 0xc8, 0xe7, 0x03,
+	0x68, 0xeb, 0x67, 0x67, 0xf6, 0x46, 0x39, 0xbc, 0x8b, 0xcb, 0x1c, 0x39, 0x50, 0xf1, 0x81, 0xa2,
+	0xe2, 0x81, 0x33, 0x46, 0x6f, 0xa1, 0xa3, 0xaf, 0x9c, 0x13, 0x81, 0x3c, 0x68, 0x86, 0x2a, 0xc9,
+	0x45, 0x00, 0xf9, 0xe0, 0xe8, 0x72, 0xc1, 0xbd, 0xae, 0xcb, 0xf5, 0xc3, 0x94, 0xc8, 0x87, 0x45,
+	0x1d, 0x5e, 0xc7, 0x45, 0x3a, 0x75, 0xef, 0xfe, 0x72, 0x6a, 0x77, 0x07, 0xc7, 0xb8, 0x3f, 0x38,
+	0xc6, 0x9f, 0x07, 0xa7, 0xf6, 0xcb, 0xd1, 0xa9, 0xdd, 0x1e, 0x1d, 0xe3, 0xfe, 0xe8, 0xd4, 0x7e,
+	0x3f, 0x3a, 0xb5, 0xa0, 0xa9, 0x94, 0x7d, 0xfd, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3a, 0x45,
+	0x1c, 0xc5, 0xce, 0x05, 0x00, 0x00,
 }
 
 func (m *FileVersion) Marshal() (dAtA []byte, err error) {
@@ -495,6 +500,15 @@ func (m *FileInfoTruncated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = 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--
@@ -647,7 +661,7 @@ func (m *BlockList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *BlocksHashOnly) Marshal() (dAtA []byte, err error) {
+func (m *IndirectionHashesOnly) Marshal() (dAtA []byte, err error) {
 	size := m.ProtoSize()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -657,16 +671,25 @@ func (m *BlocksHashOnly) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *BlocksHashOnly) MarshalTo(dAtA []byte) (int, error) {
+func (m *IndirectionHashesOnly) MarshalTo(dAtA []byte) (int, error) {
 	size := m.ProtoSize()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BlocksHashOnly) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+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)
@@ -893,6 +916,10 @@ func (m *FileInfoTruncated) ProtoSize() (n int) {
 	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
 }
 
@@ -911,7 +938,7 @@ func (m *BlockList) ProtoSize() (n int) {
 	return n
 }
 
-func (m *BlocksHashOnly) ProtoSize() (n int) {
+func (m *IndirectionHashesOnly) ProtoSize() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -921,6 +948,10 @@ func (m *BlocksHashOnly) ProtoSize() (n int) {
 	if l > 0 {
 		n += 2 + l + sovStructs(uint64(l))
 	}
+	l = len(m.VersionHash)
+	if l > 0 {
+		n += 2 + l + sovStructs(uint64(l))
+	}
 	return n
 }
 
@@ -1620,6 +1651,40 @@ func (m *FileInfoTruncated) Unmarshal(dAtA []byte) error {
 					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:])
@@ -1731,7 +1796,7 @@ func (m *BlockList) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BlocksHashOnly) Unmarshal(dAtA []byte) error {
+func (m *IndirectionHashesOnly) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1754,10 +1819,10 @@ func (m *BlocksHashOnly) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BlocksHashOnly: wiretype end group for non-group")
+			return fmt.Errorf("proto: IndirectionHashesOnly: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BlocksHashOnly: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: IndirectionHashesOnly: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 18:
@@ -1794,6 +1859,40 @@ func (m *BlocksHashOnly) Unmarshal(dAtA []byte) error {
 				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:])

lib/db/structs.proto

@@ -42,7 +42,8 @@ message FileInfoTruncated {
     int32                 block_size     = 13 [(gogoproto.customname) = "RawBlockSize"];
 
     // see bep.proto
-    uint32 local_flags = 1000;
+    uint32 local_flags  = 1000;
+    bytes  version_hash = 1001;
 
     bool deleted        = 6;
     bool invalid        = 7 [(gogoproto.customname) = "RawInvalid"];
@@ -54,9 +55,11 @@ message BlockList {
     repeated protocol.BlockInfo Blocks = 1 [(gogoproto.nullable) = false];
 }
 
-// BlocksHashOnly is used to only unmarshal the block list hash from a FileInfo
-message BlocksHashOnly {
-    bytes blocks_hash = 18;
+// IndirectionHashesOnly is used to only unmarshal the indirection hashes
+// from a FileInfo
+message IndirectionHashesOnly {
+    bytes blocks_hash  = 18;
+    bytes version_hash = 1001;
 }
 
 // For each folder and device we keep one of these to track the current

lib/db/transactions.go

@@ -79,6 +79,9 @@ func (t readOnlyTransaction) unmarshalTrunc(bs []byte, trunc bool) (FileIntf, er
 		if err != nil {
 			return nil, err
 		}
+		if err := t.fillTruncated(&tf); err != nil {
+			return nil, err
+		}
 		return tf, nil
 	}
 
@@ -92,7 +95,8 @@ func (t readOnlyTransaction) unmarshalTrunc(bs []byte, trunc bool) (FileIntf, er
 	return fi, nil
 }
 
-// fillFileInfo follows the (possible) indirection of blocks and fills it out.
+// fillFileInfo follows the (possible) indirection of blocks and version
+// vector and fills it out.
 func (t readOnlyTransaction) fillFileInfo(fi *protocol.FileInfo) error {
 	var key []byte
 
@@ -110,6 +114,41 @@ func (t readOnlyTransaction) fillFileInfo(fi *protocol.FileInfo) error {
 		fi.Blocks = bl.Blocks
 	}
 
+	if len(fi.VersionHash) != 0 {
+		key = t.keyer.GenerateVersionKey(key, fi.VersionHash)
+		bs, err := t.Get(key)
+		if err != nil {
+			return err
+		}
+		var v protocol.Vector
+		if err := v.Unmarshal(bs); err != nil {
+			return err
+		}
+		fi.Version = v
+	}
+
+	return nil
+}
+
+// fillTruncated follows the (possible) indirection of version vector and
+// fills it.
+func (t readOnlyTransaction) fillTruncated(fi *FileInfoTruncated) error {
+	var key []byte
+
+	if len(fi.VersionHash) == 0 {
+		return nil
+	}
+
+	key = t.keyer.GenerateVersionKey(key, fi.VersionHash)
+	bs, err := t.Get(key)
+	if err != nil {
+		return err
+	}
+	var v protocol.Vector
+	if err := v.Unmarshal(bs); err != nil {
+		return err
+	}
+	fi.Version = v
 	return nil
 }
 
@@ -511,6 +550,24 @@ func (t readWriteTransaction) putFile(fkey []byte, fi protocol.FileInfo, truncat
 		fi.Blocks = nil
 	}
 
+	// Indirect the version vector if it's large enough.
+	if len(fi.Version.Counters) > versionIndirectionCutoff {
+		fi.VersionHash = protocol.VectorHash(fi.Version)
+		bkey = t.keyer.GenerateVersionKey(bkey, fi.VersionHash)
+		if _, err := t.Get(bkey); backend.IsNotFound(err) {
+			// Marshal the version vector and save it
+			versionBs := mustMarshal(&fi.Version)
+			if err := t.Put(bkey, versionBs); err != nil {
+				return err
+			}
+		} else if err != nil {
+			return err
+		}
+		fi.Version = protocol.Vector{}
+	} else {
+		fi.VersionHash = nil
+	}
+
 	fiBs := mustMarshal(&fi)
 	return t.Put(fkey, fiBs)
 }

lib/model/model.go

@@ -924,6 +924,7 @@ func (m *model) handleIndex(deviceID protocol.DeviceID, folder string, fs []prot
 		// The local attributes should never be transmitted over the wire.
 		// Make sure they look like they weren't.
 		fs[i].LocalFlags = 0
+		fs[i].VersionHash = nil
 	}
 	files.Update(deviceID, fs)
 
@@ -1968,7 +1969,10 @@ func (s *indexSender) sendIndexTo(ctx context.Context) error {
 		if f.IsReceiveOnlyChanged() {
 			f.Version = protocol.Vector{}
 		}
-		f.LocalFlags = 0 // never sent externally
+
+		// never sent externally
+		f.LocalFlags = 0
+		f.VersionHash = nil
 
 		previousWasDelete = f.IsDeleted()
 

lib/protocol/bep.pb.go

@@ -506,7 +506,10 @@ type FileInfo struct {
 	// host only. It is not part of the protocol, doesn't get sent or
 	// received (we make sure to zero it), nonetheless we need it on our
 	// struct and to be able to serialize it to/from the database.
-	LocalFlags    uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"local_flags,omitempty"`
+	LocalFlags uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"local_flags,omitempty"`
+	// The version_hash is an implementation detail and not part of the wire
+	// format.
+	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"`
@@ -922,122 +925,123 @@ func init() {
 func init() { proto.RegisterFile("bep.proto", fileDescriptor_e3f59eb60afbbc6e) }
 
 var fileDescriptor_e3f59eb60afbbc6e = []byte{
-	// 1825 bytes of a gzipped FileDescriptorProto
+	// 1842 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x73, 0xdb, 0xc6,
-	0x15, 0x26, 0x48, 0xf0, 0xd7, 0x23, 0xa5, 0x40, 0x6b, 0x5b, 0x45, 0x61, 0x9b, 0x84, 0x69, 0x3b,
-	0x66, 0x34, 0xa9, 0xed, 0x26, 0x69, 0x3b, 0xed, 0xb4, 0x9d, 0xe1, 0x0f, 0x48, 0xe6, 0x54, 0x26,
-	0xd5, 0x25, 0xe5, 0xd4, 0x39, 0x14, 0x03, 0x11, 0x4b, 0x0a, 0x63, 0x10, 0xcb, 0x02, 0xa0, 0x64,
-	0xe6, 0x4f, 0xe0, 0xa9, 0xc7, 0x5e, 0x38, 0x93, 0x99, 0x9e, 0xfa, 0x9f, 0xf8, 0xe8, 0xf6, 0xd4,
-	0xe9, 0x41, 0xd3, 0xc8, 0x97, 0x1c, 0x7b, 0xe9, 0xb5, 0xed, 0xec, 0x2e, 0x40, 0x82, 0x52, 0x9c,
-	0xc9, 0xa1, 0x27, 0xec, 0xbe, 0xf7, 0xed, 0x5b, 0xec, 0xf7, 0xde, 0xfb, 0x76, 0xa1, 0x78, 0x42,
-	0xa6, 0x8f, 0xa7, 0x3e, 0x0d, 0x29, 0x2a, 0xf0, 0xcf, 0x90, 0xba, 0xda, 0x7d, 0x9f, 0x4c, 0x69,
-	0xf0, 0x84, 0xcf, 0x4f, 0x66, 0xa3, 0x27, 0x63, 0x3a, 0xa6, 0x7c, 0xc2, 0x47, 0x02, 0x5e, 0x9b,
-	0x42, 0xf6, 0x19, 0x71, 0x5d, 0x8a, 0xaa, 0x50, 0xb2, 0xc9, 0x99, 0x33, 0x24, 0xa6, 0x67, 0x4d,
-	0x88, 0x2a, 0xe9, 0x52, 0xbd, 0x88, 0x41, 0x98, 0xba, 0xd6, 0x84, 0x30, 0xc0, 0xd0, 0x75, 0x88,
-	0x17, 0x0a, 0x40, 0x5a, 0x00, 0x84, 0x89, 0x03, 0x1e, 0xc2, 0x76, 0x04, 0x38, 0x23, 0x7e, 0xe0,
-	0x50, 0x4f, 0xcd, 0x70, 0xcc, 0x96, 0xb0, 0xbe, 0x10, 0xc6, 0x5a, 0x00, 0xb9, 0x67, 0xc4, 0xb2,
-	0x89, 0x8f, 0x3e, 0x02, 0x39, 0x9c, 0x4f, 0xc5, 0x5e, 0xdb, 0x9f, 0xdc, 0x7a, 0x1c, 0xff, 0xf9,
-	0xe3, 0xe7, 0x24, 0x08, 0xac, 0x31, 0x19, 0xcc, 0xa7, 0x04, 0x73, 0x08, 0xfa, 0x35, 0x94, 0x86,
-	0x74, 0x32, 0xf5, 0x49, 0xc0, 0x03, 0xa7, 0xf9, 0x8a, 0x3b, 0xd7, 0x56, 0xb4, 0xd6, 0x18, 0x9c,
-	0x5c, 0x50, 0x6b, 0xc0, 0x56, 0xcb, 0x9d, 0x05, 0x21, 0xf1, 0x5b, 0xd4, 0x1b, 0x39, 0x63, 0xf4,
-	0x14, 0xf2, 0x23, 0xea, 0xda, 0xc4, 0x0f, 0x54, 0x49, 0xcf, 0xd4, 0x4b, 0x9f, 0x28, 0xeb, 0x60,
-	0xfb, 0xdc, 0xd1, 0x94, 0xdf, 0x5c, 0x54, 0x53, 0x38, 0x86, 0xd5, 0xfe, 0x9c, 0x86, 0x9c, 0xf0,
-	0xa0, 0x5d, 0x48, 0x3b, 0xb6, 0xa0, 0xa8, 0x99, 0xbb, 0xbc, 0xa8, 0xa6, 0x3b, 0x6d, 0x9c, 0x76,
-	0x6c, 0x74, 0x13, 0xb2, 0xae, 0x75, 0x42, 0xdc, 0x88, 0x1c, 0x31, 0x41, 0xb7, 0xa1, 0xe8, 0x13,
-	0xcb, 0x36, 0xa9, 0xe7, 0xce, 0x39, 0x25, 0x05, 0x5c, 0x60, 0x86, 0x9e, 0xe7, 0xce, 0xd1, 0x8f,
-	0x00, 0x39, 0x63, 0x8f, 0xfa, 0xc4, 0x9c, 0x12, 0x7f, 0xe2, 0xf0, 0xbf, 0x0d, 0x54, 0x99, 0xa3,
-	0x76, 0x84, 0xe7, 0x68, 0xed, 0x40, 0xf7, 0x61, 0x2b, 0x82, 0xdb, 0xc4, 0x25, 0x21, 0x51, 0xb3,
-	0x1c, 0x59, 0x16, 0xc6, 0x36, 0xb7, 0xa1, 0xa7, 0x70, 0xd3, 0x76, 0x02, 0xeb, 0xc4, 0x25, 0x66,
-	0x48, 0x26, 0x53, 0xd3, 0xf1, 0x6c, 0xf2, 0x9a, 0x04, 0x6a, 0x8e, 0x63, 0x51, 0xe4, 0x1b, 0x90,
-	0xc9, 0xb4, 0x23, 0x3c, 0x68, 0x17, 0x72, 0x53, 0x6b, 0x16, 0x10, 0x5b, 0xcd, 0x73, 0x4c, 0x34,
-	0x63, 0x2c, 0x89, 0x0a, 0x08, 0x54, 0xe5, 0x2a, 0x4b, 0x6d, 0xee, 0x88, 0x59, 0x8a, 0x60, 0xb5,
-	0x7f, 0xa5, 0x21, 0x27, 0x3c, 0xe8, 0xc3, 0x15, 0x4b, 0xe5, 0xe6, 0x2e, 0x43, 0xfd, 0xe3, 0xa2,
-	0x5a, 0x10, 0xbe, 0x4e, 0x3b, 0xc1, 0x1a, 0x02, 0x39, 0x51, 0x51, 0x7c, 0x8c, 0xee, 0x40, 0xd1,
-	0xb2, 0x6d, 0x96, 0x3d, 0x12, 0xa8, 0x19, 0x3d, 0x53, 0x2f, 0xe2, 0xb5, 0x01, 0xfd, 0x6c, 0xb3,
-	0x1a, 0xe4, 0xab, 0xf5, 0xf3, 0xbe, 0x32, 0x60, 0xa9, 0x18, 0x12, 0x3f, 0xaa, 0xe0, 0x2c, 0xdf,
-	0xaf, 0xc0, 0x0c, 0xbc, 0x7e, 0xef, 0x41, 0x79, 0x62, 0xbd, 0x36, 0x03, 0xf2, 0x87, 0x19, 0xf1,
-	0x86, 0x84, 0xd3, 0x95, 0xc1, 0xa5, 0x89, 0xf5, 0xba, 0x1f, 0x99, 0x50, 0x05, 0xc0, 0xf1, 0x42,
-	0x9f, 0xda, 0xb3, 0x21, 0xf1, 0x23, 0xae, 0x12, 0x16, 0xf4, 0x13, 0x28, 0x70, 0xb2, 0x4d, 0xc7,
-	0x56, 0x0b, 0xba, 0x54, 0x97, 0x9b, 0x5a, 0x74, 0xf0, 0x3c, 0xa7, 0x9a, 0x9f, 0x3b, 0x1e, 0xe2,
-	0x3c, 0xc7, 0x76, 0x6c, 0xf4, 0x4b, 0xd0, 0x82, 0x57, 0x0e, 0x4b, 0x94, 0x88, 0x14, 0x3a, 0xd4,
-	0x33, 0x7d, 0x32, 0xa1, 0x67, 0x96, 0x1b, 0xa8, 0x45, 0xbe, 0x8d, 0xca, 0x10, 0x9d, 0x04, 0x00,
-	0x47, 0xfe, 0x5a, 0x0f, 0xb2, 0x3c, 0x22, 0xcb, 0xa2, 0x28, 0xd6, 0xa8, 0x7b, 0xa3, 0x19, 0x7a,
-	0x0c, 0xd9, 0x91, 0xe3, 0x92, 0x40, 0x4d, 0xf3, 0x1c, 0xa2, 0x44, 0xa5, 0x3b, 0x2e, 0xe9, 0x78,
-	0x23, 0x1a, 0x65, 0x51, 0xc0, 0x6a, 0xc7, 0x50, 0xe2, 0x01, 0x8f, 0xa7, 0xb6, 0x15, 0x92, 0xff,
-	0x5b, 0xd8, 0xff, 0xca, 0x50, 0x88, 0x3d, 0xab, 0xa4, 0x4b, 0x89, 0xa4, 0x23, 0x90, 0x03, 0xe7,
-	0x4b, 0xc2, 0x7b, 0x24, 0x83, 0xf9, 0x18, 0xdd, 0x05, 0x98, 0x50, 0xdb, 0x19, 0x39, 0xc4, 0x36,
-	0x03, 0x9e, 0xb2, 0x0c, 0x2e, 0xc6, 0x96, 0x3e, 0x7a, 0x0a, 0xa5, 0x95, 0xfb, 0x64, 0xae, 0x96,
-	0x39, 0xe7, 0x1f, 0xc4, 0x9c, 0xf7, 0x4f, 0xa9, 0x1f, 0x76, 0xda, 0x78, 0x15, 0xa2, 0x39, 0x67,
-	0x25, 0x1d, 0xcb, 0x13, 0x23, 0x76, 0xa3, 0xa4, 0x5f, 0x90, 0x61, 0x48, 0x57, 0x8d, 0x1f, 0xc1,
-	0x90, 0x06, 0x85, 0x55, 0x4d, 0x00, 0xff, 0x81, 0xd5, 0x1c, 0xfd, 0x18, 0x72, 0x27, 0x2e, 0x1d,
-	0xbe, 0x8a, 0xfb, 0xe3, 0xc6, 0x3a, 0x58, 0x93, 0xd9, 0x13, 0x2c, 0x44, 0x40, 0x26, 0x93, 0xc1,
-	0x7c, 0xe2, 0x3a, 0xde, 0x2b, 0x33, 0xb4, 0xfc, 0x31, 0x09, 0xd5, 0x1d, 0x21, 0x93, 0x91, 0x75,
-	0xc0, 0x8d, 0x4c, 0x6e, 0xc5, 0x02, 0xf3, 0xd4, 0x0a, 0x4e, 0x55, 0xc4, 0xda, 0x08, 0x83, 0x30,
-	0x3d, 0xb3, 0x82, 0x53, 0xb4, 0x17, 0xa9, 0xa7, 0xd0, 0xc2, 0xdd, 0xeb, 0xec, 0x27, 0xe4, 0x53,
-	0x87, 0xd2, 0x55, 0x79, 0xd9, 0xc2, 0x49, 0x13, 0xdb, 0x6e, 0x45, 0xa4, 0x17, 0xa8, 0x25, 0x5d,
-	0xaa, 0x67, 0xd7, 0xbc, 0x75, 0x03, 0xf4, 0x04, 0xc4, 0xe6, 0x26, 0x4f, 0xd1, 0x16, 0xf3, 0x37,
-	0x95, 0xcb, 0x8b, 0x6a, 0x19, 0x5b, 0xe7, 0xfc, 0xa8, 0x7d, 0xe7, 0x4b, 0x82, 0x8b, 0x27, 0xf1,
-	0x90, 0xed, 0xe9, 0xd2, 0xa1, 0xe5, 0x9a, 0x23, 0xd7, 0x1a, 0x07, 0xea, 0x37, 0x79, 0xbe, 0x29,
-	0x70, 0xdb, 0x3e, 0x33, 0x21, 0x95, 0xa9, 0x0b, 0x53, 0x2c, 0x3b, 0x92, 0xa6, 0x78, 0x8a, 0xea,
-	0x90, 0x77, 0xbc, 0x33, 0xcb, 0x75, 0x22, 0x41, 0x6a, 0x6e, 0x5f, 0x5e, 0x54, 0x01, 0x5b, 0xe7,
-	0x1d, 0x61, 0xc5, 0xb1, 0x9b, 0xb1, 0xe9, 0xd1, 0x0d, 0xed, 0x2c, 0xf0, 0x50, 0x5b, 0x1e, 0x4d,
-	0xe8, 0xe6, 0x2f, 0xe4, 0x3f, 0x7d, 0x55, 0x4d, 0xd5, 0x3c, 0x28, 0xae, 0xb2, 0xc2, 0xaa, 0x8d,
-	0x33, 0x9b, 0xe1, 0xcc, 0xf2, 0x31, 0x2b, 0x75, 0x3a, 0x1a, 0x05, 0x24, 0xe4, 0x75, 0x99, 0xc1,
-	0xd1, 0x6c, 0x55, 0x99, 0x69, 0x4e, 0x8b, 0xa8, 0xcc, 0xdb, 0x50, 0x3c, 0x27, 0xd6, 0x2b, 0x91,
-	0x1e, 0xc1, 0x68, 0x81, 0x19, 0x58, 0x72, 0xa2, 0xfd, 0x7e, 0x05, 0x39, 0x51, 0x52, 0xe8, 0x53,
-	0x28, 0x0c, 0xe9, 0xcc, 0x0b, 0xd7, 0xf7, 0xcd, 0x4e, 0x52, 0xae, 0xb8, 0x27, 0xaa, 0x93, 0x15,
-	0xb0, 0xb6, 0x0f, 0xf9, 0xc8, 0x85, 0x1e, 0xae, 0xb4, 0x54, 0x6e, 0xde, 0xba, 0x52, 0xde, 0x9b,
-	0x17, 0xd0, 0x99, 0xe5, 0xce, 0xc4, 0x8f, 0xca, 0x58, 0x4c, 0x6a, 0x7f, 0x95, 0x20, 0x8f, 0x59,
-	0xc5, 0x06, 0x61, 0xe2, 0xea, 0xca, 0x6e, 0x5c, 0x5d, 0xeb, 0x26, 0x4f, 0x6f, 0x34, 0x79, 0xdc,
-	0xa7, 0x99, 0x44, 0x9f, 0xae, 0x59, 0x92, 0xbf, 0x95, 0xa5, 0x6c, 0x82, 0xa5, 0x98, 0xe5, 0x5c,
-	0x82, 0xe5, 0x87, 0xb0, 0x3d, 0xf2, 0xe9, 0x84, 0x5f, 0x4e, 0xd4, 0xb7, 0xfc, 0x79, 0xa4, 0xa4,
-	0x5b, 0xcc, 0x3a, 0x88, 0x8d, 0x9b, 0x04, 0x17, 0x36, 0x09, 0xae, 0x99, 0x50, 0xc0, 0x24, 0x98,
-	0x52, 0x2f, 0x20, 0xef, 0x3d, 0x13, 0x02, 0xd9, 0xb6, 0x42, 0x8b, 0x9f, 0xa8, 0x8c, 0xf9, 0x18,
-	0x3d, 0x02, 0x79, 0x48, 0x6d, 0x71, 0x9e, 0xed, 0x64, 0xbb, 0x1a, 0xbe, 0x4f, 0xfd, 0x16, 0xb5,
-	0x09, 0xe6, 0x80, 0xda, 0x14, 0x94, 0x36, 0x3d, 0xf7, 0x5c, 0x6a, 0xd9, 0x47, 0x3e, 0x1d, 0xb3,
-	0x1b, 0xe4, 0xbd, 0x4a, 0xd8, 0x86, 0xfc, 0x8c, 0x6b, 0x65, 0xac, 0x85, 0x0f, 0x36, 0xbb, 0xf1,
-	0x6a, 0x20, 0x21, 0xac, 0xb1, 0xce, 0x44, 0x4b, 0x6b, 0xff, 0x96, 0x40, 0x7b, 0x3f, 0x1a, 0x75,
-	0xa0, 0x24, 0x90, 0x66, 0xe2, 0xd1, 0x54, 0xff, 0x3e, 0x1b, 0x71, 0x21, 0x80, 0xd9, 0x6a, 0xfc,
-	0xad, 0x37, 0x6e, 0x42, 0x17, 0x33, 0xdf, 0x4f, 0x17, 0x1f, 0xc1, 0x96, 0x50, 0x84, 0xf8, 0x7d,
-	0x21, 0xeb, 0x99, 0x7a, 0xb6, 0x99, 0x56, 0x52, 0xb8, 0x7c, 0x22, 0xda, 0x4c, 0xbc, 0x2e, 0xee,
-	0x6e, 0x48, 0x87, 0xa8, 0x8e, 0xb5, 0x50, 0xd4, 0x72, 0x20, 0x1f, 0x39, 0xde, 0xb8, 0x56, 0x85,
-	0x6c, 0xcb, 0xa5, 0x3c, 0x9f, 0x39, 0x9f, 0x58, 0x01, 0xf5, 0x62, 0x9a, 0xc5, 0x6c, 0xef, 0x6f,
-	0x69, 0x28, 0x25, 0x9e, 0x86, 0xe8, 0x29, 0x6c, 0xb7, 0x0e, 0x8f, 0xfb, 0x03, 0x03, 0x9b, 0xad,
-	0x5e, 0x77, 0xbf, 0x73, 0xa0, 0xa4, 0xb4, 0x3b, 0x8b, 0xa5, 0xae, 0x4e, 0xd6, 0xa0, 0xcd, 0x57,
-	0x5f, 0x15, 0xb2, 0x9d, 0x6e, 0xdb, 0xf8, 0x9d, 0x22, 0x69, 0x37, 0x17, 0x4b, 0x5d, 0x49, 0x00,
-	0xc5, 0x15, 0xfa, 0x31, 0x94, 0x39, 0xc0, 0x3c, 0x3e, 0x6a, 0x37, 0x06, 0x86, 0x92, 0xd6, 0xb4,
-	0xc5, 0x52, 0xdf, 0xbd, 0x8a, 0x8b, 0x52, 0x72, 0x1f, 0xf2, 0xd8, 0xf8, 0xed, 0xb1, 0xd1, 0x1f,
-	0x28, 0x19, 0x6d, 0x77, 0xb1, 0xd4, 0x51, 0x02, 0x18, 0x77, 0xdc, 0x43, 0x28, 0x60, 0xa3, 0x7f,
-	0xd4, 0xeb, 0xf6, 0x0d, 0x45, 0xd6, 0x7e, 0xb0, 0x58, 0xea, 0x37, 0x36, 0x50, 0x51, 0x11, 0xff,
-	0x14, 0x76, 0xda, 0xbd, 0xcf, 0xbb, 0x87, 0xbd, 0x46, 0xdb, 0x3c, 0xc2, 0xbd, 0x03, 0x6c, 0xf4,
-	0xfb, 0x4a, 0x56, 0xab, 0x2e, 0x96, 0xfa, 0xed, 0x04, 0xfe, 0x5a, 0x4d, 0xde, 0x05, 0xf9, 0xa8,
-	0xd3, 0x3d, 0x50, 0x72, 0xda, 0x8d, 0xc5, 0x52, 0xff, 0x20, 0x01, 0x65, 0xa4, 0xb2, 0x13, 0xb7,
-	0x0e, 0x7b, 0x7d, 0x43, 0xc9, 0x5f, 0x3b, 0x31, 0x27, 0x7b, 0xef, 0xf7, 0x80, 0xae, 0x3f, 0x9e,
-	0xd1, 0x03, 0x90, 0xbb, 0xbd, 0xae, 0xa1, 0xa4, 0xc4, 0xf9, 0xaf, 0x23, 0xba, 0xd4, 0x23, 0xa8,
-	0x06, 0x99, 0xc3, 0x2f, 0x3e, 0x53, 0x24, 0xed, 0x87, 0x8b, 0xa5, 0x7e, 0xeb, 0x3a, 0xe8, 0xf0,
-	0x8b, 0xcf, 0xf6, 0x28, 0x94, 0x92, 0x81, 0x6b, 0x50, 0x78, 0x6e, 0x0c, 0x1a, 0xed, 0xc6, 0xa0,
-	0xa1, 0xa4, 0xc4, 0x2f, 0xc5, 0xee, 0xe7, 0x24, 0xb4, 0x78, 0x8f, 0xde, 0x81, 0x6c, 0xd7, 0x78,
-	0x61, 0x60, 0x45, 0xd2, 0x76, 0x16, 0x4b, 0x7d, 0x2b, 0x06, 0x74, 0xc9, 0x19, 0xf1, 0x51, 0x05,
-	0x72, 0x8d, 0xc3, 0xcf, 0x1b, 0x2f, 0xfb, 0x4a, 0x5a, 0x43, 0x8b, 0xa5, 0xbe, 0x1d, 0xbb, 0x1b,
-	0xee, 0xb9, 0x35, 0x0f, 0xf6, 0xfe, 0x23, 0x41, 0x39, 0x79, 0x05, 0xa2, 0x0a, 0xc8, 0xfb, 0x9d,
-	0x43, 0x23, 0xde, 0x2e, 0xe9, 0x63, 0x63, 0x54, 0x87, 0x62, 0xbb, 0x83, 0x8d, 0xd6, 0xa0, 0x87,
-	0x5f, 0xc6, 0x67, 0x49, 0x82, 0xda, 0x8e, 0xcf, 0xeb, 0x7f, 0x8e, 0x7e, 0x0e, 0xe5, 0xfe, 0xcb,
-	0xe7, 0x87, 0x9d, 0xee, 0x6f, 0x4c, 0x1e, 0x31, 0xad, 0x3d, 0x5a, 0x2c, 0xf5, 0x7b, 0x1b, 0x60,
-	0x32, 0xf5, 0xc9, 0xd0, 0x0a, 0x89, 0xdd, 0x17, 0xd7, 0x39, 0x73, 0x16, 0x24, 0xd4, 0x82, 0x9d,
-	0x78, 0xe9, 0x7a, 0xb3, 0x8c, 0xf6, 0xf1, 0x62, 0xa9, 0x7f, 0xf8, 0x9d, 0xeb, 0x57, 0xbb, 0x17,
-	0x24, 0xf4, 0x00, 0xf2, 0x51, 0x90, 0xb8, 0x92, 0x92, 0x4b, 0xa3, 0x05, 0x7b, 0x7f, 0x91, 0xa0,
-	0xb8, 0x52, 0x33, 0x46, 0x78, 0xb7, 0x67, 0x1a, 0x18, 0xf7, 0x70, 0xcc, 0xc0, 0xca, 0xd9, 0xa5,
-	0x7c, 0x88, 0xee, 0x41, 0xfe, 0xc0, 0xe8, 0x1a, 0xb8, 0xd3, 0x8a, 0x1b, 0x63, 0x05, 0x39, 0x20,
-	0x1e, 0xf1, 0x9d, 0x21, 0xfa, 0x08, 0xca, 0xdd, 0x9e, 0xd9, 0x3f, 0x6e, 0x3d, 0x8b, 0x8f, 0xce,
-	0xf7, 0x4f, 0x84, 0xea, 0xcf, 0x86, 0xa7, 0x9c, 0xcf, 0x3d, 0xd6, 0x43, 0x2f, 0x1a, 0x87, 0x9d,
-	0xb6, 0x80, 0x66, 0x34, 0x75, 0xb1, 0xd4, 0x6f, 0xae, 0xa0, 0xd1, 0x1d, 0xce, 0xb0, 0x7b, 0x36,
-	0x54, 0xbe, 0x5b, 0xb7, 0x90, 0x0e, 0xb9, 0xc6, 0xd1, 0x91, 0xd1, 0x6d, 0xc7, 0x7f, 0xbf, 0xf6,
-	0x35, 0xa6, 0x53, 0xe2, 0xd9, 0x0c, 0xb1, 0xdf, 0xc3, 0x07, 0xc6, 0x20, 0xfe, 0xf9, 0x35, 0x62,
-	0x9f, 0xb2, 0xb7, 0x54, 0xb3, 0xfe, 0xe6, 0xeb, 0x4a, 0xea, 0xed, 0xd7, 0x95, 0xd4, 0x9b, 0xcb,
-	0x8a, 0xf4, 0xf6, 0xb2, 0x22, 0xfd, 0xf3, 0xb2, 0x92, 0xfa, 0xe6, 0xb2, 0x22, 0xfd, 0xf1, 0x5d,
-	0x25, 0xf5, 0xd5, 0xbb, 0x8a, 0xf4, 0xf6, 0x5d, 0x25, 0xf5, 0xf7, 0x77, 0x95, 0xd4, 0x49, 0x8e,
-	0x6b, 0xde, 0xa7, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x3f, 0x75, 0x30, 0x0d, 0x51, 0x0f, 0x00,
-	0x00,
+	0xf5, 0x27, 0x48, 0xf0, 0xd7, 0x23, 0xa5, 0x40, 0x6b, 0x5b, 0x5f, 0x7c, 0x61, 0x9b, 0x84, 0x69,
+	0x3b, 0x66, 0x34, 0xa9, 0xed, 0x26, 0x69, 0x3b, 0xed, 0xb4, 0x9d, 0xe1, 0x0f, 0x48, 0xe6, 0x54,
+	0x26, 0xd5, 0x25, 0xe5, 0xd4, 0x39, 0x14, 0x03, 0x11, 0x4b, 0x0a, 0x63, 0x10, 0xcb, 0x02, 0xa0,
+	0x64, 0xe6, 0x4f, 0xe0, 0xa9, 0xc7, 0x5e, 0x38, 0x93, 0x99, 0x9c, 0xfa, 0x9f, 0xf8, 0xe8, 0xf6,
+	0xd4, 0xe9, 0x41, 0xd3, 0xc8, 0x97, 0xf4, 0xd6, 0x4b, 0xaf, 0x9d, 0xce, 0xee, 0x02, 0x24, 0x28,
+	0xc5, 0x99, 0x1c, 0x7a, 0xc2, 0xee, 0x7b, 0x9f, 0x7d, 0xbb, 0xef, 0xb3, 0xef, 0x7d, 0x16, 0x50,
+	0x3c, 0x21, 0xd3, 0xc7, 0x53, 0x9f, 0x86, 0x14, 0x15, 0xf8, 0x67, 0x48, 0x5d, 0xed, 0xbe, 0x4f,
+	0xa6, 0x34, 0x78, 0xc2, 0xe7, 0x27, 0xb3, 0xd1, 0x93, 0x31, 0x1d, 0x53, 0x3e, 0xe1, 0x23, 0x01,
+	0xaf, 0x4d, 0x21, 0xfb, 0x8c, 0xb8, 0x2e, 0x45, 0x55, 0x28, 0xd9, 0xe4, 0xcc, 0x19, 0x12, 0xd3,
+	0xb3, 0x26, 0x44, 0x95, 0x74, 0xa9, 0x5e, 0xc4, 0x20, 0x4c, 0x5d, 0x6b, 0x42, 0x18, 0x60, 0xe8,
+	0x3a, 0xc4, 0x0b, 0x05, 0x20, 0x2d, 0x00, 0xc2, 0xc4, 0x01, 0x0f, 0x61, 0x3b, 0x02, 0x9c, 0x11,
+	0x3f, 0x70, 0xa8, 0xa7, 0x66, 0x38, 0x66, 0x4b, 0x58, 0x5f, 0x08, 0x63, 0x2d, 0x80, 0xdc, 0x33,
+	0x62, 0xd9, 0xc4, 0x47, 0x1f, 0x81, 0x1c, 0xce, 0xa7, 0x62, 0xaf, 0xed, 0x4f, 0x6e, 0x3d, 0x8e,
+	0x4f, 0xfe, 0xf8, 0x39, 0x09, 0x02, 0x6b, 0x4c, 0x06, 0xf3, 0x29, 0xc1, 0x1c, 0x82, 0x7e, 0x0d,
+	0xa5, 0x21, 0x9d, 0x4c, 0x7d, 0x12, 0xf0, 0xc0, 0x69, 0xbe, 0xe2, 0xce, 0xb5, 0x15, 0xad, 0x35,
+	0x06, 0x27, 0x17, 0xd4, 0x1a, 0xb0, 0xd5, 0x72, 0x67, 0x41, 0x48, 0xfc, 0x16, 0xf5, 0x46, 0xce,
+	0x18, 0x3d, 0x85, 0xfc, 0x88, 0xba, 0x36, 0xf1, 0x03, 0x55, 0xd2, 0x33, 0xf5, 0xd2, 0x27, 0xca,
+	0x3a, 0xd8, 0x3e, 0x77, 0x34, 0xe5, 0x37, 0x17, 0xd5, 0x14, 0x8e, 0x61, 0xb5, 0xaf, 0xd3, 0x90,
+	0x13, 0x1e, 0xb4, 0x0b, 0x69, 0xc7, 0x16, 0x14, 0x35, 0x73, 0x97, 0x17, 0xd5, 0x74, 0xa7, 0x8d,
+	0xd3, 0x8e, 0x8d, 0x6e, 0x42, 0xd6, 0xb5, 0x4e, 0x88, 0x1b, 0x91, 0x23, 0x26, 0xe8, 0x36, 0x14,
+	0x7d, 0x62, 0xd9, 0x26, 0xf5, 0xdc, 0x39, 0xa7, 0xa4, 0x80, 0x0b, 0xcc, 0xd0, 0xf3, 0xdc, 0x39,
+	0xfa, 0x11, 0x20, 0x67, 0xec, 0x51, 0x9f, 0x98, 0x53, 0xe2, 0x4f, 0x1c, 0x7e, 0xda, 0x40, 0x95,
+	0x39, 0x6a, 0x47, 0x78, 0x8e, 0xd6, 0x0e, 0x74, 0x1f, 0xb6, 0x22, 0xb8, 0x4d, 0x5c, 0x12, 0x12,
+	0x35, 0xcb, 0x91, 0x65, 0x61, 0x6c, 0x73, 0x1b, 0x7a, 0x0a, 0x37, 0x6d, 0x27, 0xb0, 0x4e, 0x5c,
+	0x62, 0x86, 0x64, 0x32, 0x35, 0x1d, 0xcf, 0x26, 0xaf, 0x49, 0xa0, 0xe6, 0x38, 0x16, 0x45, 0xbe,
+	0x01, 0x99, 0x4c, 0x3b, 0xc2, 0x83, 0x76, 0x21, 0x37, 0xb5, 0x66, 0x01, 0xb1, 0xd5, 0x3c, 0xc7,
+	0x44, 0x33, 0xc6, 0x92, 0xa8, 0x80, 0x40, 0x55, 0xae, 0xb2, 0xd4, 0xe6, 0x8e, 0x98, 0xa5, 0x08,
+	0x56, 0xfb, 0x57, 0x1a, 0x72, 0xc2, 0x83, 0x3e, 0x5c, 0xb1, 0x54, 0x6e, 0xee, 0x32, 0xd4, 0xdf,
+	0x2f, 0xaa, 0x05, 0xe1, 0xeb, 0xb4, 0x13, 0xac, 0x21, 0x90, 0x13, 0x15, 0xc5, 0xc7, 0xe8, 0x0e,
+	0x14, 0x2d, 0xdb, 0x66, 0xb7, 0x47, 0x02, 0x35, 0xa3, 0x67, 0xea, 0x45, 0xbc, 0x36, 0xa0, 0x9f,
+	0x6d, 0x56, 0x83, 0x7c, 0xb5, 0x7e, 0xde, 0x57, 0x06, 0xec, 0x2a, 0x86, 0xc4, 0x8f, 0x2a, 0x38,
+	0xcb, 0xf7, 0x2b, 0x30, 0x03, 0xaf, 0xdf, 0x7b, 0x50, 0x9e, 0x58, 0xaf, 0xcd, 0x80, 0xfc, 0x61,
+	0x46, 0xbc, 0x21, 0xe1, 0x74, 0x65, 0x70, 0x69, 0x62, 0xbd, 0xee, 0x47, 0x26, 0x54, 0x01, 0x70,
+	0xbc, 0xd0, 0xa7, 0xf6, 0x6c, 0x48, 0xfc, 0x88, 0xab, 0x84, 0x05, 0xfd, 0x04, 0x0a, 0x9c, 0x6c,
+	0xd3, 0xb1, 0xd5, 0x82, 0x2e, 0xd5, 0xe5, 0xa6, 0x16, 0x25, 0x9e, 0xe7, 0x54, 0xf3, 0xbc, 0xe3,
+	0x21, 0xce, 0x73, 0x6c, 0xc7, 0x46, 0xbf, 0x04, 0x2d, 0x78, 0xe5, 0xb0, 0x8b, 0x12, 0x91, 0x42,
+	0x87, 0x7a, 0xa6, 0x4f, 0x26, 0xf4, 0xcc, 0x72, 0x03, 0xb5, 0xc8, 0xb7, 0x51, 0x19, 0xa2, 0x93,
+	0x00, 0xe0, 0xc8, 0x5f, 0xeb, 0x41, 0x96, 0x47, 0x64, 0xb7, 0x28, 0x8a, 0x35, 0xea, 0xde, 0x68,
+	0x86, 0x1e, 0x43, 0x76, 0xe4, 0xb8, 0x24, 0x50, 0xd3, 0xfc, 0x0e, 0x51, 0xa2, 0xd2, 0x1d, 0x97,
+	0x74, 0xbc, 0x11, 0x8d, 0x6e, 0x51, 0xc0, 0x6a, 0xc7, 0x50, 0xe2, 0x01, 0x8f, 0xa7, 0xb6, 0x15,
+	0x92, 0xff, 0x59, 0xd8, 0xaf, 0xb3, 0x50, 0x88, 0x3d, 0xab, 0x4b, 0x97, 0x12, 0x97, 0x8e, 0x40,
+	0x0e, 0x9c, 0x2f, 0x09, 0xef, 0x91, 0x0c, 0xe6, 0x63, 0x74, 0x17, 0x60, 0x42, 0x6d, 0x67, 0xe4,
+	0x10, 0xdb, 0x0c, 0xf8, 0x95, 0x65, 0x70, 0x31, 0xb6, 0xf4, 0xd1, 0x53, 0x28, 0xad, 0xdc, 0x27,
+	0x73, 0xb5, 0xcc, 0x39, 0xff, 0x20, 0xe6, 0xbc, 0x7f, 0x4a, 0xfd, 0xb0, 0xd3, 0xc6, 0xab, 0x10,
+	0xcd, 0x39, 0x2b, 0xe9, 0x58, 0x9e, 0x18, 0xb1, 0x1b, 0x25, 0xfd, 0x82, 0x0c, 0x43, 0xba, 0x6a,
+	0xfc, 0x08, 0x86, 0x34, 0x28, 0xac, 0x6a, 0x02, 0xf8, 0x01, 0x56, 0x73, 0xf4, 0x63, 0xc8, 0x9d,
+	0xb8, 0x74, 0xf8, 0x2a, 0xee, 0x8f, 0x1b, 0xeb, 0x60, 0x4d, 0x66, 0x4f, 0xb0, 0x10, 0x01, 0x99,
+	0x4c, 0x06, 0xf3, 0x89, 0xeb, 0x78, 0xaf, 0xcc, 0xd0, 0xf2, 0xc7, 0x24, 0x54, 0x77, 0x84, 0x4c,
+	0x46, 0xd6, 0x01, 0x37, 0x32, 0xb9, 0x15, 0x0b, 0xcc, 0x53, 0x2b, 0x38, 0x55, 0x11, 0x6b, 0x23,
+	0x0c, 0xc2, 0xf4, 0xcc, 0x0a, 0x4e, 0xd1, 0x5e, 0xa4, 0x9e, 0x42, 0x0b, 0x77, 0xaf, 0xb3, 0x9f,
+	0x90, 0x4f, 0x1d, 0x4a, 0x57, 0xe5, 0x65, 0x0b, 0x27, 0x4d, 0x6c, 0xbb, 0x15, 0x91, 0x5e, 0xa0,
+	0x96, 0x74, 0xa9, 0x9e, 0x5d, 0xf3, 0xd6, 0x0d, 0xd0, 0x13, 0x10, 0x9b, 0x9b, 0xfc, 0x8a, 0xb6,
+	0x98, 0xbf, 0xa9, 0x5c, 0x5e, 0x54, 0xcb, 0xd8, 0x3a, 0xe7, 0xa9, 0xf6, 0x9d, 0x2f, 0x09, 0x2e,
+	0x9e, 0xc4, 0x43, 0xb6, 0xa7, 0x4b, 0x87, 0x96, 0x6b, 0x8e, 0x5c, 0x6b, 0x1c, 0xa8, 0xdf, 0xe6,
+	0xf9, 0xa6, 0xc0, 0x6d, 0xfb, 0xcc, 0x84, 0x6a, 0x50, 0x8e, 0x38, 0x16, 0x39, 0xfe, 0x33, 0xcf,
+	0x93, 0x2c, 0x45, 0x46, 0x9e, 0xa5, 0xca, 0x14, 0x88, 0xa9, 0x9a, 0x1d, 0xc9, 0x57, 0x3c, 0x45,
+	0x75, 0xc8, 0x3b, 0xde, 0x99, 0xe5, 0x3a, 0x91, 0x68, 0x35, 0xb7, 0x2f, 0x2f, 0xaa, 0x80, 0xad,
+	0xf3, 0x8e, 0xb0, 0xe2, 0xd8, 0xcd, 0x18, 0xf7, 0xe8, 0x86, 0xbe, 0x16, 0x78, 0xa8, 0x2d, 0x8f,
+	0x26, 0xb4, 0xf5, 0x17, 0xf2, 0x9f, 0xbe, 0xaa, 0xa6, 0x6a, 0x1e, 0x14, 0x57, 0x37, 0xc7, 0x2a,
+	0x92, 0x9f, 0x2c, 0xc3, 0x0f, 0xc6, 0xc7, 0xac, 0x1d, 0xe8, 0x68, 0x14, 0x90, 0x90, 0xd7, 0x6e,
+	0x06, 0x47, 0xb3, 0x55, 0xf5, 0xa6, 0x39, 0x75, 0xa2, 0x7a, 0x6f, 0x43, 0xf1, 0x9c, 0x58, 0xaf,
+	0x44, 0x7a, 0x82, 0xf5, 0x02, 0x33, 0xb0, 0xd4, 0xa2, 0xfd, 0x7e, 0x05, 0x39, 0x51, 0x76, 0xe8,
+	0x53, 0x28, 0x0c, 0xe9, 0xcc, 0x0b, 0xd7, 0x6f, 0xd2, 0x4e, 0x52, 0xd2, 0xb8, 0x27, 0xaa, 0xa5,
+	0x15, 0xb0, 0xb6, 0x0f, 0xf9, 0xc8, 0x85, 0x1e, 0xae, 0xf4, 0x56, 0x6e, 0xde, 0xba, 0xd2, 0x02,
+	0x9b, 0x8f, 0xd4, 0x99, 0xe5, 0xce, 0xc4, 0x41, 0x65, 0x2c, 0x26, 0xb5, 0xbf, 0x48, 0x90, 0xc7,
+	0xac, 0xaa, 0x83, 0x30, 0xf1, 0xbc, 0x65, 0x37, 0x9e, 0xb7, 0xb5, 0x10, 0xa4, 0x37, 0x84, 0x20,
+	0xee, 0xe5, 0x4c, 0xa2, 0x97, 0xd7, 0x2c, 0xc9, 0xdf, 0xc9, 0x52, 0x36, 0xc1, 0x52, 0xcc, 0x72,
+	0x2e, 0xc1, 0xf2, 0x43, 0xd8, 0x1e, 0xf9, 0x74, 0xc2, 0x1f, 0x30, 0xea, 0x5b, 0xfe, 0x3c, 0x52,
+	0xdb, 0x2d, 0x66, 0x1d, 0xc4, 0xc6, 0x4d, 0x82, 0x0b, 0x9b, 0x04, 0xd7, 0x4c, 0x28, 0x60, 0x12,
+	0x4c, 0xa9, 0x17, 0x90, 0xf7, 0xe6, 0x84, 0x40, 0xb6, 0xad, 0xd0, 0xe2, 0x19, 0x95, 0x31, 0x1f,
+	0xa3, 0x47, 0x20, 0x0f, 0xa9, 0x2d, 0xf2, 0xd9, 0x4e, 0xb6, 0xb4, 0xe1, 0xfb, 0xd4, 0x6f, 0x51,
+	0x9b, 0x60, 0x0e, 0xa8, 0x4d, 0x41, 0x69, 0xd3, 0x73, 0xcf, 0xa5, 0x96, 0x7d, 0xe4, 0xd3, 0x31,
+	0x7b, 0x65, 0xde, 0xab, 0x96, 0x6d, 0xc8, 0xcf, 0xb8, 0x9e, 0xc6, 0x7a, 0xf9, 0x60, 0xb3, 0x63,
+	0xaf, 0x06, 0x12, 0xe2, 0x1b, 0x6b, 0x51, 0xb4, 0xb4, 0xf6, 0x6f, 0x09, 0xb4, 0xf7, 0xa3, 0x51,
+	0x07, 0x4a, 0x02, 0x69, 0x26, 0x7e, 0xac, 0xea, 0x3f, 0x64, 0x23, 0x2e, 0x16, 0x30, 0x5b, 0x8d,
+	0xbf, 0xf3, 0x55, 0x4e, 0x68, 0x67, 0xe6, 0x87, 0x69, 0xe7, 0x23, 0xd8, 0x12, 0xaa, 0x11, 0xff,
+	0x83, 0xc8, 0x7a, 0xa6, 0x9e, 0x6d, 0xa6, 0x95, 0x14, 0x2e, 0x9f, 0x88, 0x36, 0x13, 0x7f, 0x20,
+	0x77, 0x37, 0xe4, 0x45, 0x54, 0xc7, 0x5a, 0x4c, 0x6a, 0x39, 0x90, 0x8f, 0x1c, 0x6f, 0x5c, 0xab,
+	0x42, 0xb6, 0xe5, 0x52, 0x7e, 0x9f, 0x39, 0x9f, 0x58, 0x01, 0xf5, 0x62, 0x9a, 0xc5, 0x6c, 0xef,
+	0xaf, 0x69, 0x28, 0x25, 0x7e, 0x1f, 0xd1, 0x53, 0xd8, 0x6e, 0x1d, 0x1e, 0xf7, 0x07, 0x06, 0x36,
+	0x5b, 0xbd, 0xee, 0x7e, 0xe7, 0x40, 0x49, 0x69, 0x77, 0x16, 0x4b, 0x5d, 0x9d, 0xac, 0x41, 0x9b,
+	0x7f, 0x86, 0x55, 0xc8, 0x76, 0xba, 0x6d, 0xe3, 0x77, 0x8a, 0xa4, 0xdd, 0x5c, 0x2c, 0x75, 0x25,
+	0x01, 0x14, 0xcf, 0xec, 0xc7, 0x50, 0xe6, 0x00, 0xf3, 0xf8, 0xa8, 0xdd, 0x18, 0x18, 0x4a, 0x5a,
+	0xd3, 0x16, 0x4b, 0x7d, 0xf7, 0x2a, 0x2e, 0xba, 0x92, 0xfb, 0x90, 0xc7, 0xc6, 0x6f, 0x8f, 0x8d,
+	0xfe, 0x40, 0xc9, 0x68, 0xbb, 0x8b, 0xa5, 0x8e, 0x12, 0xc0, 0xb8, 0xe3, 0x1e, 0x42, 0x01, 0x1b,
+	0xfd, 0xa3, 0x5e, 0xb7, 0x6f, 0x28, 0xb2, 0xf6, 0x7f, 0x8b, 0xa5, 0x7e, 0x63, 0x03, 0x15, 0x15,
+	0xf1, 0x4f, 0x61, 0xa7, 0xdd, 0xfb, 0xbc, 0x7b, 0xd8, 0x6b, 0xb4, 0xcd, 0x23, 0xdc, 0x3b, 0xc0,
+	0x46, 0xbf, 0xaf, 0x64, 0xb5, 0xea, 0x62, 0xa9, 0xdf, 0x4e, 0xe0, 0xaf, 0xd5, 0xe4, 0x5d, 0x90,
+	0x8f, 0x3a, 0xdd, 0x03, 0x25, 0xa7, 0xdd, 0x58, 0x2c, 0xf5, 0x0f, 0x12, 0x50, 0x46, 0x2a, 0xcb,
+	0xb8, 0x75, 0xd8, 0xeb, 0x1b, 0x4a, 0xfe, 0x5a, 0xc6, 0x9c, 0xec, 0xbd, 0xdf, 0x03, 0xba, 0xfe,
+	0x83, 0x8d, 0x1e, 0x80, 0xdc, 0xed, 0x75, 0x0d, 0x25, 0x25, 0xf2, 0xbf, 0x8e, 0xe8, 0x52, 0x8f,
+	0xa0, 0x1a, 0x64, 0x0e, 0xbf, 0xf8, 0x4c, 0x91, 0xb4, 0xff, 0x5f, 0x2c, 0xf5, 0x5b, 0xd7, 0x41,
+	0x87, 0x5f, 0x7c, 0xb6, 0x47, 0xa1, 0x94, 0x0c, 0x5c, 0x83, 0xc2, 0x73, 0x63, 0xd0, 0x68, 0x37,
+	0x06, 0x0d, 0x25, 0x25, 0x8e, 0x14, 0xbb, 0x9f, 0x93, 0xd0, 0xe2, 0x3d, 0x7a, 0x07, 0xb2, 0x5d,
+	0xe3, 0x85, 0x81, 0x15, 0x49, 0xdb, 0x59, 0x2c, 0xf5, 0xad, 0x18, 0xd0, 0x25, 0x67, 0xc4, 0x47,
+	0x15, 0xc8, 0x35, 0x0e, 0x3f, 0x6f, 0xbc, 0xec, 0x2b, 0x69, 0x0d, 0x2d, 0x96, 0xfa, 0x76, 0xec,
+	0x6e, 0xb8, 0xe7, 0xd6, 0x3c, 0xd8, 0xfb, 0x8f, 0x04, 0xe5, 0xe4, 0x33, 0x89, 0x2a, 0x20, 0xef,
+	0x77, 0x0e, 0x8d, 0x78, 0xbb, 0xa4, 0x8f, 0x8d, 0x51, 0x1d, 0x8a, 0xed, 0x0e, 0x36, 0x5a, 0x83,
+	0x1e, 0x7e, 0x19, 0xe7, 0x92, 0x04, 0xb5, 0x1d, 0x9f, 0xd7, 0xff, 0x1c, 0xfd, 0x1c, 0xca, 0xfd,
+	0x97, 0xcf, 0x0f, 0x3b, 0xdd, 0xdf, 0x98, 0x3c, 0x62, 0x5a, 0x7b, 0xb4, 0x58, 0xea, 0xf7, 0x36,
+	0xc0, 0x64, 0xea, 0x93, 0xa1, 0x15, 0x12, 0xbb, 0x2f, 0x9e, 0x7c, 0xe6, 0x2c, 0x48, 0xa8, 0x05,
+	0x3b, 0xf1, 0xd2, 0xf5, 0x66, 0x19, 0xed, 0xe3, 0xc5, 0x52, 0xff, 0xf0, 0x7b, 0xd7, 0xaf, 0x76,
+	0x2f, 0x48, 0xe8, 0x01, 0xe4, 0xa3, 0x20, 0x71, 0x25, 0x25, 0x97, 0x46, 0x0b, 0xf6, 0xfe, 0x2c,
+	0x41, 0x71, 0xa5, 0x66, 0x8c, 0xf0, 0x6e, 0xcf, 0x34, 0x30, 0xee, 0xe1, 0x98, 0x81, 0x95, 0xb3,
+	0x4b, 0xf9, 0x10, 0xdd, 0x83, 0xfc, 0x81, 0xd1, 0x35, 0x70, 0xa7, 0x15, 0x37, 0xc6, 0x0a, 0x72,
+	0x40, 0x3c, 0xe2, 0x3b, 0x43, 0xf4, 0x11, 0x94, 0xbb, 0x3d, 0xb3, 0x7f, 0xdc, 0x7a, 0x16, 0xa7,
+	0xce, 0xf7, 0x4f, 0x84, 0xea, 0xcf, 0x86, 0xa7, 0x9c, 0xcf, 0x3d, 0xd6, 0x43, 0x2f, 0x1a, 0x87,
+	0x9d, 0xb6, 0x80, 0x66, 0x34, 0x75, 0xb1, 0xd4, 0x6f, 0xae, 0xa0, 0xd1, 0x1b, 0xce, 0xb0, 0x7b,
+	0x36, 0x54, 0xbe, 0x5f, 0xb7, 0x90, 0x0e, 0xb9, 0xc6, 0xd1, 0x91, 0xd1, 0x6d, 0xc7, 0xa7, 0x5f,
+	0xfb, 0x1a, 0xd3, 0x29, 0xf1, 0x6c, 0x86, 0xd8, 0xef, 0xe1, 0x03, 0x63, 0x10, 0x1f, 0x7e, 0x8d,
+	0xd8, 0xa7, 0xec, 0x7f, 0xab, 0x59, 0x7f, 0xf3, 0x4d, 0x25, 0xf5, 0xf6, 0x9b, 0x4a, 0xea, 0xcd,
+	0x65, 0x45, 0x7a, 0x7b, 0x59, 0x91, 0xfe, 0x71, 0x59, 0x49, 0x7d, 0x7b, 0x59, 0x91, 0xfe, 0xf8,
+	0xae, 0x92, 0xfa, 0xea, 0x5d, 0x45, 0x7a, 0xfb, 0xae, 0x92, 0xfa, 0xdb, 0xbb, 0x4a, 0xea, 0x24,
+	0xc7, 0x35, 0xef, 0xd3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x99, 0x31, 0x0e, 0x75, 0x0f,
+	0x00, 0x00,
 }
 
 func (m *Hello) Marshal() (dAtA []byte, err error) {
@@ -1456,6 +1460,15 @@ func (m *FileInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if len(m.VersionHash) > 0 {
+		i -= len(m.VersionHash)
+		copy(dAtA[i:], m.VersionHash)
+		i = encodeVarintBep(dAtA, i, uint64(len(m.VersionHash)))
+		i--
+		dAtA[i] = 0x3e
+		i--
+		dAtA[i] = 0xca
+	}
 	if m.LocalFlags != 0 {
 		i = encodeVarintBep(dAtA, i, uint64(m.LocalFlags))
 		i--
@@ -2210,6 +2223,10 @@ func (m *FileInfo) ProtoSize() (n int) {
 	if m.LocalFlags != 0 {
 		n += 2 + sovBep(uint64(m.LocalFlags))
 	}
+	l = len(m.VersionHash)
+	if l > 0 {
+		n += 2 + l + sovBep(uint64(l))
+	}
 	return n
 }
 
@@ -3913,6 +3930,40 @@ func (m *FileInfo) Unmarshal(dAtA []byte) error {
 					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 ErrIntOverflowBep
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthBep
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthBep
+			}
+			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 := skipBep(dAtA[iNdEx:])

lib/protocol/bep.proto

@@ -119,6 +119,9 @@ message FileInfo {
     // received (we make sure to zero it), nonetheless we need it on our
     // struct and to be able to serialize it to/from the database.
     uint32 local_flags = 1000;
+    // The version_hash is an implementation detail and not part of the wire
+    // format.
+    bytes version_hash = 1001;
 
     bool deleted        = 6;
     bool invalid        = 7 [(gogoproto.customname) = "RawInvalid"];

lib/protocol/bep_extensions.go

@@ -360,3 +360,16 @@ func BlocksHash(bs []BlockInfo) []byte {
 	}
 	return h.Sum(nil)
 }
+
+func VectorHash(v Vector) []byte {
+	h := sha256.New()
+	for _, c := range v.Counters {
+		if err := binary.Write(h, binary.BigEndian, c.ID); err != nil {
+			panic("impossible: failed to write c.ID to hash function: " + err.Error())
+		}
+		if err := binary.Write(h, binary.BigEndian, c.Value); err != nil {
+			panic("impossible: failed to write c.Value to hash function: " + err.Error())
+		}
+	}
+	return h.Sum(nil)
+}

lib/sha256/sha256.go

@@ -26,6 +26,7 @@ const (
 	benchmarkingDuration   = 150 * time.Millisecond
 	defaultImpl            = "crypto/sha256"
 	minioImpl              = "minio/sha256-simd"
+	Size                   = cryptoSha256.Size
 )
 
 // May be switched out for another implementation