// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lib/config/folderconfiguration.proto

package config

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	fs "github.com/syncthing/syncthing/lib/fs"
	github_com_syncthing_syncthing_lib_protocol "github.com/syncthing/syncthing/lib/protocol"
	_ "github.com/syncthing/syncthing/proto/ext"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type FolderDeviceConfiguration struct {
	DeviceID           github_com_syncthing_syncthing_lib_protocol.DeviceID `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3,customtype=github.com/syncthing/syncthing/lib/protocol.DeviceID" json:"deviceID" xml:"id,attr"`
	IntroducedBy       github_com_syncthing_syncthing_lib_protocol.DeviceID `protobuf:"bytes,2,opt,name=introduced_by,json=introducedBy,proto3,customtype=github.com/syncthing/syncthing/lib/protocol.DeviceID" json:"introducedBy" xml:"introducedBy,attr"`
	EncryptionPassword string                                               `protobuf:"bytes,3,opt,name=encryption_password,json=encryptionPassword,proto3" json:"encryptionPassword" xml:"encryptionPassword"`
}

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

var xxx_messageInfo_FolderDeviceConfiguration proto.InternalMessageInfo

type FolderConfiguration struct {
	ID                      string                      `protobuf:"bytes,1,opt,name=id,proto3" json:"id" xml:"id,attr" nodefault:"true"`
	Label                   string                      `protobuf:"bytes,2,opt,name=label,proto3" json:"label" xml:"label,attr" restart:"false"`
	FilesystemType          fs.FilesystemType           `protobuf:"varint,3,opt,name=filesystem_type,json=filesystemType,proto3,enum=fs.FilesystemType" json:"filesystemType" xml:"filesystemType"`
	Path                    string                      `protobuf:"bytes,4,opt,name=path,proto3" json:"path" xml:"path,attr" default:"~"`
	Type                    FolderType                  `protobuf:"varint,5,opt,name=type,proto3,enum=config.FolderType" json:"type" xml:"type,attr"`
	Devices                 []FolderDeviceConfiguration `protobuf:"bytes,6,rep,name=devices,proto3" json:"devices" xml:"device"`
	RescanIntervalS         int                         `protobuf:"varint,7,opt,name=rescan_interval_s,json=rescanIntervalS,proto3,casttype=int" json:"rescanIntervalS" xml:"rescanIntervalS,attr" default:"3600"`
	FSWatcherEnabled        bool                        `protobuf:"varint,8,opt,name=fs_watcher_enabled,json=fsWatcherEnabled,proto3" json:"fsWatcherEnabled" xml:"fsWatcherEnabled,attr" default:"true"`
	FSWatcherDelayS         float64                     `protobuf:"fixed64,9,opt,name=fs_watcher_delay_s,json=fsWatcherDelayS,proto3" json:"fsWatcherDelayS" xml:"fsWatcherDelayS,attr" default:"10"`
	FSWatcherTimeoutS       float64                     `protobuf:"fixed64,40,opt,name=fs_watcher_timeout_s,json=fsWatcherTimeoutS,proto3" json:"fsWatcherTimeoutS" xml:"fsWatcherTimeoutS,attr"`
	IgnorePerms             bool                        `protobuf:"varint,10,opt,name=ignore_perms,json=ignorePerms,proto3" json:"ignorePerms" xml:"ignorePerms,attr"`
	AutoNormalize           bool                        `protobuf:"varint,11,opt,name=auto_normalize,json=autoNormalize,proto3" json:"autoNormalize" xml:"autoNormalize,attr" default:"true"`
	MinDiskFree             Size                        `protobuf:"bytes,12,opt,name=min_disk_free,json=minDiskFree,proto3" json:"minDiskFree" xml:"minDiskFree" default:"1 %"`
	Versioning              VersioningConfiguration     `protobuf:"bytes,13,opt,name=versioning,proto3" json:"versioning" xml:"versioning"`
	Copiers                 int                         `protobuf:"varint,14,opt,name=copiers,proto3,casttype=int" json:"copiers" xml:"copiers"`
	PullerMaxPendingKiB     int                         `protobuf:"varint,15,opt,name=puller_max_pending_kib,json=pullerMaxPendingKib,proto3,casttype=int" json:"pullerMaxPendingKiB" xml:"pullerMaxPendingKiB"`
	Hashers                 int                         `protobuf:"varint,16,opt,name=hashers,proto3,casttype=int" json:"hashers" xml:"hashers"`
	Order                   PullOrder                   `protobuf:"varint,17,opt,name=order,proto3,enum=config.PullOrder" json:"order" xml:"order"`
	IgnoreDelete            bool                        `protobuf:"varint,18,opt,name=ignore_delete,json=ignoreDelete,proto3" json:"ignoreDelete" xml:"ignoreDelete"`
	ScanProgressIntervalS   int                         `protobuf:"varint,19,opt,name=scan_progress_interval_s,json=scanProgressIntervalS,proto3,casttype=int" json:"scanProgressIntervalS" xml:"scanProgressIntervalS"`
	PullerPauseS            int                         `protobuf:"varint,20,opt,name=puller_pause_s,json=pullerPauseS,proto3,casttype=int" json:"pullerPauseS" xml:"pullerPauseS"`
	MaxConflicts            int                         `protobuf:"varint,21,opt,name=max_conflicts,json=maxConflicts,proto3,casttype=int" json:"maxConflicts" xml:"maxConflicts" default:"10"`
	DisableSparseFiles      bool                        `protobuf:"varint,22,opt,name=disable_sparse_files,json=disableSparseFiles,proto3" json:"disableSparseFiles" xml:"disableSparseFiles"`
	DisableTempIndexes      bool                        `protobuf:"varint,23,opt,name=disable_temp_indexes,json=disableTempIndexes,proto3" json:"disableTempIndexes" xml:"disableTempIndexes"`
	Paused                  bool                        `protobuf:"varint,24,opt,name=paused,proto3" json:"paused" xml:"paused"`
	WeakHashThresholdPct    int                         `protobuf:"varint,25,opt,name=weak_hash_threshold_pct,json=weakHashThresholdPct,proto3,casttype=int" json:"weakHashThresholdPct" xml:"weakHashThresholdPct"`
	MarkerName              string                      `protobuf:"bytes,26,opt,name=marker_name,json=markerName,proto3" json:"markerName" xml:"markerName"`
	CopyOwnershipFromParent bool                        `protobuf:"varint,27,opt,name=copy_ownership_from_parent,json=copyOwnershipFromParent,proto3" json:"copyOwnershipFromParent" xml:"copyOwnershipFromParent"`
	RawModTimeWindowS       int                         `protobuf:"varint,28,opt,name=mod_time_window_s,json=modTimeWindowS,proto3,casttype=int" json:"modTimeWindowS" xml:"modTimeWindowS"`
	MaxConcurrentWrites     int                         `protobuf:"varint,29,opt,name=max_concurrent_writes,json=maxConcurrentWrites,proto3,casttype=int" json:"maxConcurrentWrites" xml:"maxConcurrentWrites" default:"2"`
	DisableFsync            bool                        `protobuf:"varint,30,opt,name=disable_fsync,json=disableFsync,proto3" json:"disableFsync" xml:"disableFsync"`
	BlockPullOrder          BlockPullOrder              `protobuf:"varint,31,opt,name=block_pull_order,json=blockPullOrder,proto3,enum=config.BlockPullOrder" json:"blockPullOrder" xml:"blockPullOrder"`
	CopyRangeMethod         fs.CopyRangeMethod          `protobuf:"varint,32,opt,name=copy_range_method,json=copyRangeMethod,proto3,enum=fs.CopyRangeMethod" json:"copyRangeMethod" xml:"copyRangeMethod" default:"standard"`
	CaseSensitiveFS         bool                        `protobuf:"varint,33,opt,name=case_sensitive_fs,json=caseSensitiveFs,proto3" json:"caseSensitiveFS" xml:"caseSensitiveFS"`
	JunctionsAsDirs         bool                        `protobuf:"varint,34,opt,name=follow_junctions,json=followJunctions,proto3" json:"junctionsAsDirs" xml:"junctionsAsDirs"`
	SyncOwnership           bool                        `protobuf:"varint,35,opt,name=sync_ownership,json=syncOwnership,proto3" json:"syncOwnership" xml:"syncOwnership"`
	SendOwnership           bool                        `protobuf:"varint,36,opt,name=send_ownership,json=sendOwnership,proto3" json:"sendOwnership" xml:"sendOwnership"`
	SyncXattrs              bool                        `protobuf:"varint,37,opt,name=sync_xattrs,json=syncXattrs,proto3" json:"syncXattrs" xml:"syncXattrs"`
	SendXattrs              bool                        `protobuf:"varint,38,opt,name=send_xattrs,json=sendXattrs,proto3" json:"sendXattrs" xml:"sendXattrs"`
	XattrFilter             XattrFilter                 `protobuf:"bytes,39,opt,name=xattr_filter,json=xattrFilter,proto3" json:"xattrFilter" xml:"xattrFilter"`
	// Legacy deprecated
	DeprecatedReadOnly       bool    `protobuf:"varint,9000,opt,name=read_only,json=readOnly,proto3" json:"-" xml:"ro,attr,omitempty"`                       // Deprecated: Do not use.
	DeprecatedMinDiskFreePct float64 `protobuf:"fixed64,9001,opt,name=min_disk_free_pct,json=minDiskFreePct,proto3" json:"-" xml:"minDiskFreePct,omitempty"` // Deprecated: Do not use.
	DeprecatedPullers        int     `protobuf:"varint,9002,opt,name=pullers,proto3,casttype=int" json:"-" xml:"pullers,omitempty"`                          // Deprecated: Do not use.
	DeprecatedScanOwnership  bool    `protobuf:"varint,9003,opt,name=scan_ownership,json=scanOwnership,proto3" json:"-" xml:"scanOwnership,omitempty"`       // Deprecated: Do not use.
}

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

var xxx_messageInfo_FolderConfiguration proto.InternalMessageInfo

// Extended attribute filter. This is a list of patterns to match (glob
// style), each with an action (permit or deny). First match is used. If the
// filter is empty, all strings are permitted. If the filter is non-empty,
// the default action becomes deny. To counter this, you can use the "*"
// pattern to match all strings at the end of the filter. There are also
// limits on the size of accepted attributes.
type XattrFilter struct {
	Entries            []XattrFilterEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries" xml:"entry"`
	MaxSingleEntrySize int                `protobuf:"varint,2,opt,name=max_single_entry_size,json=maxSingleEntrySize,proto3,casttype=int" json:"maxSingleEntrySize" xml:"maxSingleEntrySize" default:"1024"`
	MaxTotalSize       int                `protobuf:"varint,3,opt,name=max_total_size,json=maxTotalSize,proto3,casttype=int" json:"maxTotalSize" xml:"maxTotalSize" default:"4096"`
}

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

var xxx_messageInfo_XattrFilter proto.InternalMessageInfo

type XattrFilterEntry struct {
	Match  string `protobuf:"bytes,1,opt,name=match,proto3" json:"match" xml:"match,attr"`
	Permit bool   `protobuf:"varint,2,opt,name=permit,proto3" json:"permit" xml:"permit,attr"`
}

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

var xxx_messageInfo_XattrFilterEntry proto.InternalMessageInfo

func init() {
	proto.RegisterType((*FolderDeviceConfiguration)(nil), "config.FolderDeviceConfiguration")
	proto.RegisterType((*FolderConfiguration)(nil), "config.FolderConfiguration")
	proto.RegisterType((*XattrFilter)(nil), "config.XattrFilter")
	proto.RegisterType((*XattrFilterEntry)(nil), "config.XattrFilterEntry")
}

func init() {
	proto.RegisterFile("lib/config/folderconfiguration.proto", fileDescriptor_44a9785876ed3afa)
}

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

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

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

func (m *FolderDeviceConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EncryptionPassword) > 0 {
		i -= len(m.EncryptionPassword)
		copy(dAtA[i:], m.EncryptionPassword)
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.EncryptionPassword)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.IntroducedBy.ProtoSize()
		i -= size
		if _, err := m.IntroducedBy.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.DeviceID.ProtoSize()
		i -= size
		if _, err := m.DeviceID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *FolderConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DeprecatedScanOwnership {
		i--
		if m.DeprecatedScanOwnership {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xb2
		i--
		dAtA[i] = 0xd8
	}
	if m.DeprecatedPullers != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.DeprecatedPullers))
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xb2
		i--
		dAtA[i] = 0xd0
	}
	if m.DeprecatedMinDiskFreePct != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DeprecatedMinDiskFreePct))))
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xb2
		i--
		dAtA[i] = 0xc9
	}
	if m.DeprecatedReadOnly {
		i--
		if m.DeprecatedReadOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x4
		i--
		dAtA[i] = 0xb2
		i--
		dAtA[i] = 0xc0
	}
	if m.FSWatcherTimeoutS != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FSWatcherTimeoutS))))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc1
	}
	{
		size, err := m.XattrFilter.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0xba
	if m.SendXattrs {
		i--
		if m.SendXattrs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xb0
	}
	if m.SyncXattrs {
		i--
		if m.SyncXattrs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa8
	}
	if m.SendOwnership {
		i--
		if m.SendOwnership {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xa0
	}
	if m.SyncOwnership {
		i--
		if m.SyncOwnership {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x98
	}
	if m.JunctionsAsDirs {
		i--
		if m.JunctionsAsDirs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x90
	}
	if m.CaseSensitiveFS {
		i--
		if m.CaseSensitiveFS {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x88
	}
	if m.CopyRangeMethod != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.CopyRangeMethod))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x80
	}
	if m.BlockPullOrder != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.BlockPullOrder))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf8
	}
	if m.DisableFsync {
		i--
		if m.DisableFsync {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf0
	}
	if m.MaxConcurrentWrites != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.MaxConcurrentWrites))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe8
	}
	if m.RawModTimeWindowS != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.RawModTimeWindowS))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe0
	}
	if m.CopyOwnershipFromParent {
		i--
		if m.CopyOwnershipFromParent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd8
	}
	if len(m.MarkerName) > 0 {
		i -= len(m.MarkerName)
		copy(dAtA[i:], m.MarkerName)
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.MarkerName)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	if m.WeakHashThresholdPct != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.WeakHashThresholdPct))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	if m.Paused {
		i--
		if m.Paused {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc0
	}
	if m.DisableTempIndexes {
		i--
		if m.DisableTempIndexes {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if m.DisableSparseFiles {
		i--
		if m.DisableSparseFiles {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb0
	}
	if m.MaxConflicts != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.MaxConflicts))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if m.PullerPauseS != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.PullerPauseS))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if m.ScanProgressIntervalS != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.ScanProgressIntervalS))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.IgnoreDelete {
		i--
		if m.IgnoreDelete {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.Order != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Order))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.Hashers != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Hashers))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	if m.PullerMaxPendingKiB != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.PullerMaxPendingKiB))
		i--
		dAtA[i] = 0x78
	}
	if m.Copiers != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Copiers))
		i--
		dAtA[i] = 0x70
	}
	{
		size, err := m.Versioning.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	{
		size, err := m.MinDiskFree.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	if m.AutoNormalize {
		i--
		if m.AutoNormalize {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.IgnorePerms {
		i--
		if m.IgnorePerms {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.FSWatcherDelayS != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FSWatcherDelayS))))
		i--
		dAtA[i] = 0x49
	}
	if m.FSWatcherEnabled {
		i--
		if m.FSWatcherEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.RescanIntervalS != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.RescanIntervalS))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Devices) > 0 {
		for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.Type != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x22
	}
	if m.FilesystemType != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.FilesystemType))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *XattrFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxTotalSize != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.MaxTotalSize))
		i--
		dAtA[i] = 0x18
	}
	if m.MaxSingleEntrySize != 0 {
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(m.MaxSingleEntrySize))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintFolderconfiguration(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *XattrFilterEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Permit {
		i--
		if m.Permit {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Match) > 0 {
		i -= len(m.Match)
		copy(dAtA[i:], m.Match)
		i = encodeVarintFolderconfiguration(dAtA, i, uint64(len(m.Match)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintFolderconfiguration(dAtA []byte, offset int, v uint64) int {
	offset -= sovFolderconfiguration(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *FolderDeviceConfiguration) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.DeviceID.ProtoSize()
	n += 1 + l + sovFolderconfiguration(uint64(l))
	l = m.IntroducedBy.ProtoSize()
	n += 1 + l + sovFolderconfiguration(uint64(l))
	l = len(m.EncryptionPassword)
	if l > 0 {
		n += 1 + l + sovFolderconfiguration(uint64(l))
	}
	return n
}

func (m *FolderConfiguration) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovFolderconfiguration(uint64(l))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovFolderconfiguration(uint64(l))
	}
	if m.FilesystemType != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.FilesystemType))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovFolderconfiguration(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.Type))
	}
	if len(m.Devices) > 0 {
		for _, e := range m.Devices {
			l = e.ProtoSize()
			n += 1 + l + sovFolderconfiguration(uint64(l))
		}
	}
	if m.RescanIntervalS != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.RescanIntervalS))
	}
	if m.FSWatcherEnabled {
		n += 2
	}
	if m.FSWatcherDelayS != 0 {
		n += 9
	}
	if m.IgnorePerms {
		n += 2
	}
	if m.AutoNormalize {
		n += 2
	}
	l = m.MinDiskFree.ProtoSize()
	n += 1 + l + sovFolderconfiguration(uint64(l))
	l = m.Versioning.ProtoSize()
	n += 1 + l + sovFolderconfiguration(uint64(l))
	if m.Copiers != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.Copiers))
	}
	if m.PullerMaxPendingKiB != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.PullerMaxPendingKiB))
	}
	if m.Hashers != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.Hashers))
	}
	if m.Order != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.Order))
	}
	if m.IgnoreDelete {
		n += 3
	}
	if m.ScanProgressIntervalS != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.ScanProgressIntervalS))
	}
	if m.PullerPauseS != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.PullerPauseS))
	}
	if m.MaxConflicts != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.MaxConflicts))
	}
	if m.DisableSparseFiles {
		n += 3
	}
	if m.DisableTempIndexes {
		n += 3
	}
	if m.Paused {
		n += 3
	}
	if m.WeakHashThresholdPct != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.WeakHashThresholdPct))
	}
	l = len(m.MarkerName)
	if l > 0 {
		n += 2 + l + sovFolderconfiguration(uint64(l))
	}
	if m.CopyOwnershipFromParent {
		n += 3
	}
	if m.RawModTimeWindowS != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.RawModTimeWindowS))
	}
	if m.MaxConcurrentWrites != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.MaxConcurrentWrites))
	}
	if m.DisableFsync {
		n += 3
	}
	if m.BlockPullOrder != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.BlockPullOrder))
	}
	if m.CopyRangeMethod != 0 {
		n += 2 + sovFolderconfiguration(uint64(m.CopyRangeMethod))
	}
	if m.CaseSensitiveFS {
		n += 3
	}
	if m.JunctionsAsDirs {
		n += 3
	}
	if m.SyncOwnership {
		n += 3
	}
	if m.SendOwnership {
		n += 3
	}
	if m.SyncXattrs {
		n += 3
	}
	if m.SendXattrs {
		n += 3
	}
	l = m.XattrFilter.ProtoSize()
	n += 2 + l + sovFolderconfiguration(uint64(l))
	if m.FSWatcherTimeoutS != 0 {
		n += 10
	}
	if m.DeprecatedReadOnly {
		n += 4
	}
	if m.DeprecatedMinDiskFreePct != 0 {
		n += 11
	}
	if m.DeprecatedPullers != 0 {
		n += 3 + sovFolderconfiguration(uint64(m.DeprecatedPullers))
	}
	if m.DeprecatedScanOwnership {
		n += 4
	}
	return n
}

func (m *XattrFilter) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.ProtoSize()
			n += 1 + l + sovFolderconfiguration(uint64(l))
		}
	}
	if m.MaxSingleEntrySize != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.MaxSingleEntrySize))
	}
	if m.MaxTotalSize != 0 {
		n += 1 + sovFolderconfiguration(uint64(m.MaxTotalSize))
	}
	return n
}

func (m *XattrFilterEntry) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Match)
	if l > 0 {
		n += 1 + l + sovFolderconfiguration(uint64(l))
	}
	if m.Permit {
		n += 2
	}
	return n
}

func sovFolderconfiguration(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozFolderconfiguration(x uint64) (n int) {
	return sovFolderconfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *FolderDeviceConfiguration) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFolderconfiguration
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FolderDeviceConfiguration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FolderDeviceConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DeviceID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntroducedBy", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IntroducedBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptionPassword", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptionPassword = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFolderconfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FolderConfiguration) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFolderconfiguration
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FolderConfiguration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FolderConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilesystemType", wireType)
			}
			m.FilesystemType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FilesystemType |= fs.FilesystemType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= FolderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Devices = append(m.Devices, FolderDeviceConfiguration{})
			if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RescanIntervalS", wireType)
			}
			m.RescanIntervalS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RescanIntervalS |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FSWatcherEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.FSWatcherEnabled = bool(v != 0)
		case 9:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field FSWatcherDelayS", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.FSWatcherDelayS = float64(math.Float64frombits(v))
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnorePerms", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IgnorePerms = bool(v != 0)
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AutoNormalize", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AutoNormalize = bool(v != 0)
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinDiskFree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinDiskFree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Versioning", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Versioning.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Copiers", wireType)
			}
			m.Copiers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Copiers |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PullerMaxPendingKiB", wireType)
			}
			m.PullerMaxPendingKiB = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PullerMaxPendingKiB |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hashers", wireType)
			}
			m.Hashers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hashers |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType)
			}
			m.Order = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Order |= PullOrder(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreDelete", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IgnoreDelete = bool(v != 0)
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScanProgressIntervalS", wireType)
			}
			m.ScanProgressIntervalS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScanProgressIntervalS |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PullerPauseS", wireType)
			}
			m.PullerPauseS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PullerPauseS |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxConflicts", wireType)
			}
			m.MaxConflicts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxConflicts |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableSparseFiles", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableSparseFiles = bool(v != 0)
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableTempIndexes", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableTempIndexes = bool(v != 0)
		case 24:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Paused = bool(v != 0)
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WeakHashThresholdPct", wireType)
			}
			m.WeakHashThresholdPct = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WeakHashThresholdPct |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MarkerName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MarkerName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 27:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CopyOwnershipFromParent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CopyOwnershipFromParent = bool(v != 0)
		case 28:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawModTimeWindowS", wireType)
			}
			m.RawModTimeWindowS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RawModTimeWindowS |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxConcurrentWrites", wireType)
			}
			m.MaxConcurrentWrites = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxConcurrentWrites |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableFsync", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableFsync = bool(v != 0)
		case 31:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockPullOrder", wireType)
			}
			m.BlockPullOrder = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockPullOrder |= BlockPullOrder(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CopyRangeMethod", wireType)
			}
			m.CopyRangeMethod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CopyRangeMethod |= fs.CopyRangeMethod(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 33:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CaseSensitiveFS", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CaseSensitiveFS = bool(v != 0)
		case 34:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JunctionsAsDirs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.JunctionsAsDirs = bool(v != 0)
		case 35:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncOwnership", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SyncOwnership = bool(v != 0)
		case 36:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendOwnership", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SendOwnership = bool(v != 0)
		case 37:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncXattrs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SyncXattrs = bool(v != 0)
		case 38:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendXattrs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SendXattrs = bool(v != 0)
		case 39:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XattrFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.XattrFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 40:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field FSWatcherTimeoutS", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.FSWatcherTimeoutS = float64(math.Float64frombits(v))
		case 9000:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedReadOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DeprecatedReadOnly = bool(v != 0)
		case 9001:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedMinDiskFreePct", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.DeprecatedMinDiskFreePct = float64(math.Float64frombits(v))
		case 9002:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedPullers", wireType)
			}
			m.DeprecatedPullers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeprecatedPullers |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9003:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedScanOwnership", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DeprecatedScanOwnership = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipFolderconfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *XattrFilter) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFolderconfiguration
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: XattrFilter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: XattrFilter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, XattrFilterEntry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSingleEntrySize", wireType)
			}
			m.MaxSingleEntrySize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxSingleEntrySize |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxTotalSize", wireType)
			}
			m.MaxTotalSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxTotalSize |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFolderconfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *XattrFilterEntry) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFolderconfiguration
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: XattrFilterEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: XattrFilterEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Match", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Match = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permit", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFolderconfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Permit = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipFolderconfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthFolderconfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthFolderconfiguration        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFolderconfiguration          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupFolderconfiguration = fmt.Errorf("proto: unexpected end of group")
)
