Martchus
/
syncthing
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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.
This commit is contained in:
Jakob Borg 2020-05-13 14:28:42 +02:00 committed by GitHub
parent ba4462a70b
commit 531ceb2b0f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 570 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
cmd/stindex/idxck.go
View File

@ -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
}

21
lib/db/keyer.go
View File

@ -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:]
}

66
lib/db/lowlevel.go
View File

@ -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)
}

41
lib/db/schemaupdater.go
View File

@ -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()
}

243
lib/db/structs.pb.go
View File

@ -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:])

11
lib/db/structs.proto
View File

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

59
lib/db/transactions.go
View File

@ -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)
}

6
lib/model/model.go
View File

@ -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()

283
lib/protocol/bep.pb.go
View File

@ -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:])

3
lib/protocol/bep.proto
View File

@ -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"];

13
lib/protocol/bep_extensions.go
View File

@ -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)
}

1
lib/sha256/sha256.go
View File

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