dfs.tl.pb.go

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

package dfs

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	mtproto "github.com/teamgram/proto/mtproto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

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

const (
	CRC32_UNKNOWN                      TLConstructor = 0
	CRC32_dfs_writeFilePartData        TLConstructor = 440942855
	CRC32_dfs_uploadPhotoFileV2        TLConstructor = 605082018
	CRC32_dfs_uploadProfilePhotoFileV2 TLConstructor = -870473038
	CRC32_dfs_uploadEncryptedFileV2    TLConstructor = 2043921699
	CRC32_dfs_downloadFile             TLConstructor = -692064706
	CRC32_dfs_uploadDocumentFileV2     TLConstructor = 1983081911
	CRC32_dfs_uploadGifDocumentMedia   TLConstructor = 1103416576
	CRC32_dfs_uploadMp4DocumentMedia   TLConstructor = -1566246888
	CRC32_dfs_uploadWallPaperFile      TLConstructor = -1046081450
	CRC32_dfs_uploadThemeFile          TLConstructor = -559525993
	CRC32_dfs_uploadRingtoneFile       TLConstructor = 45335985
)

var TLConstructor_name = map[int32]string{
	0:           "CRC32_UNKNOWN",
	440942855:   "CRC32_dfs_writeFilePartData",
	605082018:   "CRC32_dfs_uploadPhotoFileV2",
	-870473038:  "CRC32_dfs_uploadProfilePhotoFileV2",
	2043921699:  "CRC32_dfs_uploadEncryptedFileV2",
	-692064706:  "CRC32_dfs_downloadFile",
	1983081911:  "CRC32_dfs_uploadDocumentFileV2",
	1103416576:  "CRC32_dfs_uploadGifDocumentMedia",
	-1566246888: "CRC32_dfs_uploadMp4DocumentMedia",
	-1046081450: "CRC32_dfs_uploadWallPaperFile",
	-559525993:  "CRC32_dfs_uploadThemeFile",
	45335985:    "CRC32_dfs_uploadRingtoneFile",
}

var TLConstructor_value = map[string]int32{
	"CRC32_UNKNOWN":                      0,
	"CRC32_dfs_writeFilePartData":        440942855,
	"CRC32_dfs_uploadPhotoFileV2":        605082018,
	"CRC32_dfs_uploadProfilePhotoFileV2": -870473038,
	"CRC32_dfs_uploadEncryptedFileV2":    2043921699,
	"CRC32_dfs_downloadFile":             -692064706,
	"CRC32_dfs_uploadDocumentFileV2":     1983081911,
	"CRC32_dfs_uploadGifDocumentMedia":   1103416576,
	"CRC32_dfs_uploadMp4DocumentMedia":   -1566246888,
	"CRC32_dfs_uploadWallPaperFile":      -1046081450,
	"CRC32_dfs_uploadThemeFile":          -559525993,
	"CRC32_dfs_uploadRingtoneFile":       45335985,
}

func (x TLConstructor) String() string {
	return proto.EnumName(TLConstructor_name, int32(x))
}

func (TLConstructor) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1c9cc97391f90775, []int{0}
}

//--------------------------------------------------------------------------------------------
type TLDfsWriteFilePartData struct {
	Constructor          TLConstructor     `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64             `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	FileId               int64             `protobuf:"varint,4,opt,name=file_id,json=fileId,proto3" json:"file_id,omitempty"`
	FilePart             int32             `protobuf:"varint,5,opt,name=file_part,json=filePart,proto3" json:"file_part,omitempty"`
	Bytes                []byte            `protobuf:"bytes,6,opt,name=bytes,proto3" json:"bytes,omitempty"`
	Big                  bool              `protobuf:"varint,7,opt,name=big,proto3" json:"big,omitempty"`
	FileTotalParts       *types.Int32Value `protobuf:"bytes,8,opt,name=file_total_parts,json=fileTotalParts,proto3" json:"file_total_parts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_TLDfsWriteFilePartData proto.InternalMessageInfo

func (m *TLDfsWriteFilePartData) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsWriteFilePartData) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsWriteFilePartData) GetFileId() int64 {
	if m != nil {
		return m.FileId
	}
	return 0
}

func (m *TLDfsWriteFilePartData) GetFilePart() int32 {
	if m != nil {
		return m.FilePart
	}
	return 0
}

func (m *TLDfsWriteFilePartData) GetBytes() []byte {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *TLDfsWriteFilePartData) GetBig() bool {
	if m != nil {
		return m.Big
	}
	return false
}

func (m *TLDfsWriteFilePartData) GetFileTotalParts() *types.Int32Value {
	if m != nil {
		return m.FileTotalParts
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadPhotoFileV2 struct {
	Constructor          TLConstructor      `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64              `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	File                 *mtproto.InputFile `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadPhotoFileV2 proto.InternalMessageInfo

func (m *TLDfsUploadPhotoFileV2) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadPhotoFileV2) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadPhotoFileV2) GetFile() *mtproto.InputFile {
	if m != nil {
		return m.File
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadProfilePhotoFileV2 struct {
	Constructor          TLConstructor      `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64              `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	File                 *mtproto.InputFile `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	Video                *mtproto.InputFile `protobuf:"bytes,5,opt,name=video,proto3" json:"video,omitempty"`
	VideoStartTs         *types.DoubleValue `protobuf:"bytes,6,opt,name=video_start_ts,json=videoStartTs,proto3" json:"video_start_ts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadProfilePhotoFileV2 proto.InternalMessageInfo

func (m *TLDfsUploadProfilePhotoFileV2) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadProfilePhotoFileV2) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadProfilePhotoFileV2) GetFile() *mtproto.InputFile {
	if m != nil {
		return m.File
	}
	return nil
}

func (m *TLDfsUploadProfilePhotoFileV2) GetVideo() *mtproto.InputFile {
	if m != nil {
		return m.Video
	}
	return nil
}

func (m *TLDfsUploadProfilePhotoFileV2) GetVideoStartTs() *types.DoubleValue {
	if m != nil {
		return m.VideoStartTs
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadEncryptedFileV2 struct {
	Constructor          TLConstructor               `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64                       `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	File                 *mtproto.InputEncryptedFile `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadEncryptedFileV2 proto.InternalMessageInfo

func (m *TLDfsUploadEncryptedFileV2) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadEncryptedFileV2) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadEncryptedFileV2) GetFile() *mtproto.InputEncryptedFile {
	if m != nil {
		return m.File
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsDownloadFile struct {
	Constructor          TLConstructor              `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Location             *mtproto.InputFileLocation `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"`
	Offset               int64                      `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit                int32                      `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

var xxx_messageInfo_TLDfsDownloadFile proto.InternalMessageInfo

func (m *TLDfsDownloadFile) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsDownloadFile) GetLocation() *mtproto.InputFileLocation {
	if m != nil {
		return m.Location
	}
	return nil
}

func (m *TLDfsDownloadFile) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *TLDfsDownloadFile) GetLimit() int32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadDocumentFileV2 struct {
	Constructor          TLConstructor       `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64               `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	Media                *mtproto.InputMedia `protobuf:"bytes,4,opt,name=media,proto3" json:"media,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadDocumentFileV2 proto.InternalMessageInfo

func (m *TLDfsUploadDocumentFileV2) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadDocumentFileV2) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadDocumentFileV2) GetMedia() *mtproto.InputMedia {
	if m != nil {
		return m.Media
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadGifDocumentMedia struct {
	Constructor          TLConstructor       `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64               `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	Media                *mtproto.InputMedia `protobuf:"bytes,4,opt,name=media,proto3" json:"media,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadGifDocumentMedia proto.InternalMessageInfo

func (m *TLDfsUploadGifDocumentMedia) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadGifDocumentMedia) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadGifDocumentMedia) GetMedia() *mtproto.InputMedia {
	if m != nil {
		return m.Media
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadMp4DocumentMedia struct {
	Constructor          TLConstructor       `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64               `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	Media                *mtproto.InputMedia `protobuf:"bytes,4,opt,name=media,proto3" json:"media,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadMp4DocumentMedia proto.InternalMessageInfo

func (m *TLDfsUploadMp4DocumentMedia) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadMp4DocumentMedia) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadMp4DocumentMedia) GetMedia() *mtproto.InputMedia {
	if m != nil {
		return m.Media
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadWallPaperFile struct {
	Constructor          TLConstructor      `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64              `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	File                 *mtproto.InputFile `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	MimeType             string             `protobuf:"bytes,5,opt,name=mime_type,json=mimeType,proto3" json:"mime_type,omitempty"`
	Admin                *mtproto.Bool      `protobuf:"bytes,6,opt,name=admin,proto3" json:"admin,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadWallPaperFile proto.InternalMessageInfo

func (m *TLDfsUploadWallPaperFile) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadWallPaperFile) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadWallPaperFile) GetFile() *mtproto.InputFile {
	if m != nil {
		return m.File
	}
	return nil
}

func (m *TLDfsUploadWallPaperFile) GetMimeType() string {
	if m != nil {
		return m.MimeType
	}
	return ""
}

func (m *TLDfsUploadWallPaperFile) GetAdmin() *mtproto.Bool {
	if m != nil {
		return m.Admin
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadThemeFile struct {
	Constructor          TLConstructor      `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64              `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	File                 *mtproto.InputFile `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	Thumb                *mtproto.InputFile `protobuf:"bytes,5,opt,name=thumb,proto3" json:"thumb,omitempty"`
	MimeType             string             `protobuf:"bytes,6,opt,name=mime_type,json=mimeType,proto3" json:"mime_type,omitempty"`
	FileName             string             `protobuf:"bytes,7,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadThemeFile proto.InternalMessageInfo

func (m *TLDfsUploadThemeFile) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadThemeFile) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadThemeFile) GetFile() *mtproto.InputFile {
	if m != nil {
		return m.File
	}
	return nil
}

func (m *TLDfsUploadThemeFile) GetThumb() *mtproto.InputFile {
	if m != nil {
		return m.Thumb
	}
	return nil
}

func (m *TLDfsUploadThemeFile) GetMimeType() string {
	if m != nil {
		return m.MimeType
	}
	return ""
}

func (m *TLDfsUploadThemeFile) GetFileName() string {
	if m != nil {
		return m.FileName
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLDfsUploadRingtoneFile struct {
	Constructor          TLConstructor      `protobuf:"varint,1,opt,name=constructor,proto3,enum=dfs.TLConstructor" json:"constructor,omitempty"`
	Creator              int64              `protobuf:"varint,3,opt,name=creator,proto3" json:"creator,omitempty"`
	File                 *mtproto.InputFile `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	MimeType             string             `protobuf:"bytes,5,opt,name=mime_type,json=mimeType,proto3" json:"mime_type,omitempty"`
	FileName             string             `protobuf:"bytes,6,opt,name=file_name,json=fileName,proto3" json:"file_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_TLDfsUploadRingtoneFile proto.InternalMessageInfo

func (m *TLDfsUploadRingtoneFile) GetConstructor() TLConstructor {
	if m != nil {
		return m.Constructor
	}
	return CRC32_UNKNOWN
}

func (m *TLDfsUploadRingtoneFile) GetCreator() int64 {
	if m != nil {
		return m.Creator
	}
	return 0
}

func (m *TLDfsUploadRingtoneFile) GetFile() *mtproto.InputFile {
	if m != nil {
		return m.File
	}
	return nil
}

func (m *TLDfsUploadRingtoneFile) GetMimeType() string {
	if m != nil {
		return m.MimeType
	}
	return ""
}

func (m *TLDfsUploadRingtoneFile) GetFileName() string {
	if m != nil {
		return m.FileName
	}
	return ""
}

func init() {
	proto.RegisterEnum("dfs.TLConstructor", TLConstructor_name, TLConstructor_value)
	proto.RegisterType((*TLDfsWriteFilePartData)(nil), "dfs.TL_dfs_writeFilePartData")
	proto.RegisterType((*TLDfsUploadPhotoFileV2)(nil), "dfs.TL_dfs_uploadPhotoFileV2")
	proto.RegisterType((*TLDfsUploadProfilePhotoFileV2)(nil), "dfs.TL_dfs_uploadProfilePhotoFileV2")
	proto.RegisterType((*TLDfsUploadEncryptedFileV2)(nil), "dfs.TL_dfs_uploadEncryptedFileV2")
	proto.RegisterType((*TLDfsDownloadFile)(nil), "dfs.TL_dfs_downloadFile")
	proto.RegisterType((*TLDfsUploadDocumentFileV2)(nil), "dfs.TL_dfs_uploadDocumentFileV2")
	proto.RegisterType((*TLDfsUploadGifDocumentMedia)(nil), "dfs.TL_dfs_uploadGifDocumentMedia")
	proto.RegisterType((*TLDfsUploadMp4DocumentMedia)(nil), "dfs.TL_dfs_uploadMp4DocumentMedia")
	proto.RegisterType((*TLDfsUploadWallPaperFile)(nil), "dfs.TL_dfs_uploadWallPaperFile")
	proto.RegisterType((*TLDfsUploadThemeFile)(nil), "dfs.TL_dfs_uploadThemeFile")
	proto.RegisterType((*TLDfsUploadRingtoneFile)(nil), "dfs.TL_dfs_uploadRingtoneFile")
}

func init() { proto.RegisterFile("dfs.tl.proto", fileDescriptor_1c9cc97391f90775) }

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

func (this *TLDfsWriteFilePartData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&dfs.TLDfsWriteFilePartData{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	s = append(s, "FileId: "+fmt.Sprintf("%#v", this.FileId)+",\n")
	s = append(s, "FilePart: "+fmt.Sprintf("%#v", this.FilePart)+",\n")
	s = append(s, "Bytes: "+fmt.Sprintf("%#v", this.Bytes)+",\n")
	s = append(s, "Big: "+fmt.Sprintf("%#v", this.Big)+",\n")
	if this.FileTotalParts != nil {
		s = append(s, "FileTotalParts: "+fmt.Sprintf("%#v", this.FileTotalParts)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadPhotoFileV2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&dfs.TLDfsUploadPhotoFileV2{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.File != nil {
		s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadProfilePhotoFileV2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&dfs.TLDfsUploadProfilePhotoFileV2{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.File != nil {
		s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n")
	}
	if this.Video != nil {
		s = append(s, "Video: "+fmt.Sprintf("%#v", this.Video)+",\n")
	}
	if this.VideoStartTs != nil {
		s = append(s, "VideoStartTs: "+fmt.Sprintf("%#v", this.VideoStartTs)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadEncryptedFileV2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&dfs.TLDfsUploadEncryptedFileV2{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.File != nil {
		s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsDownloadFile) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&dfs.TLDfsDownloadFile{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	if this.Location != nil {
		s = append(s, "Location: "+fmt.Sprintf("%#v", this.Location)+",\n")
	}
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadDocumentFileV2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&dfs.TLDfsUploadDocumentFileV2{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.Media != nil {
		s = append(s, "Media: "+fmt.Sprintf("%#v", this.Media)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadGifDocumentMedia) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&dfs.TLDfsUploadGifDocumentMedia{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.Media != nil {
		s = append(s, "Media: "+fmt.Sprintf("%#v", this.Media)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadMp4DocumentMedia) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&dfs.TLDfsUploadMp4DocumentMedia{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.Media != nil {
		s = append(s, "Media: "+fmt.Sprintf("%#v", this.Media)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadWallPaperFile) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&dfs.TLDfsUploadWallPaperFile{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.File != nil {
		s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n")
	}
	s = append(s, "MimeType: "+fmt.Sprintf("%#v", this.MimeType)+",\n")
	if this.Admin != nil {
		s = append(s, "Admin: "+fmt.Sprintf("%#v", this.Admin)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadThemeFile) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&dfs.TLDfsUploadThemeFile{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.File != nil {
		s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n")
	}
	if this.Thumb != nil {
		s = append(s, "Thumb: "+fmt.Sprintf("%#v", this.Thumb)+",\n")
	}
	s = append(s, "MimeType: "+fmt.Sprintf("%#v", this.MimeType)+",\n")
	s = append(s, "FileName: "+fmt.Sprintf("%#v", this.FileName)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLDfsUploadRingtoneFile) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&dfs.TLDfsUploadRingtoneFile{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Creator: "+fmt.Sprintf("%#v", this.Creator)+",\n")
	if this.File != nil {
		s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n")
	}
	s = append(s, "MimeType: "+fmt.Sprintf("%#v", this.MimeType)+",\n")
	s = append(s, "FileName: "+fmt.Sprintf("%#v", this.FileName)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringDfsTl(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// RPCDfsClient is the client API for RPCDfs service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RPCDfsClient interface {
	DfsWriteFilePartData(ctx context.Context, in *TLDfsWriteFilePartData, opts ...grpc.CallOption) (*mtproto.Bool, error)
	DfsUploadPhotoFileV2(ctx context.Context, in *TLDfsUploadPhotoFileV2, opts ...grpc.CallOption) (*mtproto.Photo, error)
	DfsUploadProfilePhotoFileV2(ctx context.Context, in *TLDfsUploadProfilePhotoFileV2, opts ...grpc.CallOption) (*mtproto.Photo, error)
	DfsUploadEncryptedFileV2(ctx context.Context, in *TLDfsUploadEncryptedFileV2, opts ...grpc.CallOption) (*mtproto.EncryptedFile, error)
	DfsDownloadFile(ctx context.Context, in *TLDfsDownloadFile, opts ...grpc.CallOption) (*mtproto.Upload_File, error)
	DfsUploadDocumentFileV2(ctx context.Context, in *TLDfsUploadDocumentFileV2, opts ...grpc.CallOption) (*mtproto.Document, error)
	DfsUploadGifDocumentMedia(ctx context.Context, in *TLDfsUploadGifDocumentMedia, opts ...grpc.CallOption) (*mtproto.Document, error)
	DfsUploadMp4DocumentMedia(ctx context.Context, in *TLDfsUploadMp4DocumentMedia, opts ...grpc.CallOption) (*mtproto.Document, error)
	DfsUploadWallPaperFile(ctx context.Context, in *TLDfsUploadWallPaperFile, opts ...grpc.CallOption) (*mtproto.Document, error)
	DfsUploadThemeFile(ctx context.Context, in *TLDfsUploadThemeFile, opts ...grpc.CallOption) (*mtproto.Document, error)
	DfsUploadRingtoneFile(ctx context.Context, in *TLDfsUploadRingtoneFile, opts ...grpc.CallOption) (*mtproto.Document, error)
}

type rPCDfsClient struct {
	cc *grpc.ClientConn
}

func NewRPCDfsClient(cc *grpc.ClientConn) RPCDfsClient {
	return &rPCDfsClient{cc}
}

func (c *rPCDfsClient) DfsWriteFilePartData(ctx context.Context, in *TLDfsWriteFilePartData, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_writeFilePartData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadPhotoFileV2(ctx context.Context, in *TLDfsUploadPhotoFileV2, opts ...grpc.CallOption) (*mtproto.Photo, error) {
	out := new(mtproto.Photo)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadPhotoFileV2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadProfilePhotoFileV2(ctx context.Context, in *TLDfsUploadProfilePhotoFileV2, opts ...grpc.CallOption) (*mtproto.Photo, error) {
	out := new(mtproto.Photo)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadProfilePhotoFileV2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadEncryptedFileV2(ctx context.Context, in *TLDfsUploadEncryptedFileV2, opts ...grpc.CallOption) (*mtproto.EncryptedFile, error) {
	out := new(mtproto.EncryptedFile)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadEncryptedFileV2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsDownloadFile(ctx context.Context, in *TLDfsDownloadFile, opts ...grpc.CallOption) (*mtproto.Upload_File, error) {
	out := new(mtproto.Upload_File)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_downloadFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadDocumentFileV2(ctx context.Context, in *TLDfsUploadDocumentFileV2, opts ...grpc.CallOption) (*mtproto.Document, error) {
	out := new(mtproto.Document)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadDocumentFileV2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadGifDocumentMedia(ctx context.Context, in *TLDfsUploadGifDocumentMedia, opts ...grpc.CallOption) (*mtproto.Document, error) {
	out := new(mtproto.Document)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadGifDocumentMedia", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadMp4DocumentMedia(ctx context.Context, in *TLDfsUploadMp4DocumentMedia, opts ...grpc.CallOption) (*mtproto.Document, error) {
	out := new(mtproto.Document)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadMp4DocumentMedia", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadWallPaperFile(ctx context.Context, in *TLDfsUploadWallPaperFile, opts ...grpc.CallOption) (*mtproto.Document, error) {
	out := new(mtproto.Document)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadWallPaperFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadThemeFile(ctx context.Context, in *TLDfsUploadThemeFile, opts ...grpc.CallOption) (*mtproto.Document, error) {
	out := new(mtproto.Document)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadThemeFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCDfsClient) DfsUploadRingtoneFile(ctx context.Context, in *TLDfsUploadRingtoneFile, opts ...grpc.CallOption) (*mtproto.Document, error) {
	out := new(mtproto.Document)
	err := c.cc.Invoke(ctx, "/dfs.RPCDfs/dfs_uploadRingtoneFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RPCDfsServer is the server API for RPCDfs service.
type RPCDfsServer interface {
	DfsWriteFilePartData(context.Context, *TLDfsWriteFilePartData) (*mtproto.Bool, error)
	DfsUploadPhotoFileV2(context.Context, *TLDfsUploadPhotoFileV2) (*mtproto.Photo, error)
	DfsUploadProfilePhotoFileV2(context.Context, *TLDfsUploadProfilePhotoFileV2) (*mtproto.Photo, error)
	DfsUploadEncryptedFileV2(context.Context, *TLDfsUploadEncryptedFileV2) (*mtproto.EncryptedFile, error)
	DfsDownloadFile(context.Context, *TLDfsDownloadFile) (*mtproto.Upload_File, error)
	DfsUploadDocumentFileV2(context.Context, *TLDfsUploadDocumentFileV2) (*mtproto.Document, error)
	DfsUploadGifDocumentMedia(context.Context, *TLDfsUploadGifDocumentMedia) (*mtproto.Document, error)
	DfsUploadMp4DocumentMedia(context.Context, *TLDfsUploadMp4DocumentMedia) (*mtproto.Document, error)
	DfsUploadWallPaperFile(context.Context, *TLDfsUploadWallPaperFile) (*mtproto.Document, error)
	DfsUploadThemeFile(context.Context, *TLDfsUploadThemeFile) (*mtproto.Document, error)
	DfsUploadRingtoneFile(context.Context, *TLDfsUploadRingtoneFile) (*mtproto.Document, error)
}

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

func (*UnimplementedRPCDfsServer) DfsWriteFilePartData(ctx context.Context, req *TLDfsWriteFilePartData) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsWriteFilePartData not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadPhotoFileV2(ctx context.Context, req *TLDfsUploadPhotoFileV2) (*mtproto.Photo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadPhotoFileV2 not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadProfilePhotoFileV2(ctx context.Context, req *TLDfsUploadProfilePhotoFileV2) (*mtproto.Photo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadProfilePhotoFileV2 not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadEncryptedFileV2(ctx context.Context, req *TLDfsUploadEncryptedFileV2) (*mtproto.EncryptedFile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadEncryptedFileV2 not implemented")
}
func (*UnimplementedRPCDfsServer) DfsDownloadFile(ctx context.Context, req *TLDfsDownloadFile) (*mtproto.Upload_File, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsDownloadFile not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadDocumentFileV2(ctx context.Context, req *TLDfsUploadDocumentFileV2) (*mtproto.Document, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadDocumentFileV2 not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadGifDocumentMedia(ctx context.Context, req *TLDfsUploadGifDocumentMedia) (*mtproto.Document, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadGifDocumentMedia not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadMp4DocumentMedia(ctx context.Context, req *TLDfsUploadMp4DocumentMedia) (*mtproto.Document, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadMp4DocumentMedia not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadWallPaperFile(ctx context.Context, req *TLDfsUploadWallPaperFile) (*mtproto.Document, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadWallPaperFile not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadThemeFile(ctx context.Context, req *TLDfsUploadThemeFile) (*mtproto.Document, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadThemeFile not implemented")
}
func (*UnimplementedRPCDfsServer) DfsUploadRingtoneFile(ctx context.Context, req *TLDfsUploadRingtoneFile) (*mtproto.Document, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DfsUploadRingtoneFile not implemented")
}

func RegisterRPCDfsServer(s *grpc.Server, srv RPCDfsServer) {
	s.RegisterService(&_RPCDfs_serviceDesc, srv)
}

func _RPCDfs_DfsWriteFilePartData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsWriteFilePartData)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsWriteFilePartData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsWriteFilePartData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsWriteFilePartData(ctx, req.(*TLDfsWriteFilePartData))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadPhotoFileV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadPhotoFileV2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadPhotoFileV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadPhotoFileV2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadPhotoFileV2(ctx, req.(*TLDfsUploadPhotoFileV2))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadProfilePhotoFileV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadProfilePhotoFileV2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadProfilePhotoFileV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadProfilePhotoFileV2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadProfilePhotoFileV2(ctx, req.(*TLDfsUploadProfilePhotoFileV2))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadEncryptedFileV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadEncryptedFileV2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadEncryptedFileV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadEncryptedFileV2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadEncryptedFileV2(ctx, req.(*TLDfsUploadEncryptedFileV2))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsDownloadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsDownloadFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsDownloadFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsDownloadFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsDownloadFile(ctx, req.(*TLDfsDownloadFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadDocumentFileV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadDocumentFileV2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadDocumentFileV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadDocumentFileV2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadDocumentFileV2(ctx, req.(*TLDfsUploadDocumentFileV2))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadGifDocumentMedia_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadGifDocumentMedia)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadGifDocumentMedia(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadGifDocumentMedia",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadGifDocumentMedia(ctx, req.(*TLDfsUploadGifDocumentMedia))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadMp4DocumentMedia_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadMp4DocumentMedia)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadMp4DocumentMedia(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadMp4DocumentMedia",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadMp4DocumentMedia(ctx, req.(*TLDfsUploadMp4DocumentMedia))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadWallPaperFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadWallPaperFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadWallPaperFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadWallPaperFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadWallPaperFile(ctx, req.(*TLDfsUploadWallPaperFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadThemeFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadThemeFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadThemeFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadThemeFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadThemeFile(ctx, req.(*TLDfsUploadThemeFile))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCDfs_DfsUploadRingtoneFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLDfsUploadRingtoneFile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCDfsServer).DfsUploadRingtoneFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dfs.RPCDfs/DfsUploadRingtoneFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCDfsServer).DfsUploadRingtoneFile(ctx, req.(*TLDfsUploadRingtoneFile))
	}
	return interceptor(ctx, in, info, handler)
}

var _RPCDfs_serviceDesc = grpc.ServiceDesc{
	ServiceName: "dfs.RPCDfs",
	HandlerType: (*RPCDfsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "dfs_writeFilePartData",
			Handler:    _RPCDfs_DfsWriteFilePartData_Handler,
		},
		{
			MethodName: "dfs_uploadPhotoFileV2",
			Handler:    _RPCDfs_DfsUploadPhotoFileV2_Handler,
		},
		{
			MethodName: "dfs_uploadProfilePhotoFileV2",
			Handler:    _RPCDfs_DfsUploadProfilePhotoFileV2_Handler,
		},
		{
			MethodName: "dfs_uploadEncryptedFileV2",
			Handler:    _RPCDfs_DfsUploadEncryptedFileV2_Handler,
		},
		{
			MethodName: "dfs_downloadFile",
			Handler:    _RPCDfs_DfsDownloadFile_Handler,
		},
		{
			MethodName: "dfs_uploadDocumentFileV2",
			Handler:    _RPCDfs_DfsUploadDocumentFileV2_Handler,
		},
		{
			MethodName: "dfs_uploadGifDocumentMedia",
			Handler:    _RPCDfs_DfsUploadGifDocumentMedia_Handler,
		},
		{
			MethodName: "dfs_uploadMp4DocumentMedia",
			Handler:    _RPCDfs_DfsUploadMp4DocumentMedia_Handler,
		},
		{
			MethodName: "dfs_uploadWallPaperFile",
			Handler:    _RPCDfs_DfsUploadWallPaperFile_Handler,
		},
		{
			MethodName: "dfs_uploadThemeFile",
			Handler:    _RPCDfs_DfsUploadThemeFile_Handler,
		},
		{
			MethodName: "dfs_uploadRingtoneFile",
			Handler:    _RPCDfs_DfsUploadRingtoneFile_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dfs.tl.proto",
}

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

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

func (m *TLDfsWriteFilePartData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.FileTotalParts != nil {
		{
			size, err := m.FileTotalParts.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.Big {
		i--
		if m.Big {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if len(m.Bytes) > 0 {
		i -= len(m.Bytes)
		copy(dAtA[i:], m.Bytes)
		i = encodeVarintDfsTl(dAtA, i, uint64(len(m.Bytes)))
		i--
		dAtA[i] = 0x32
	}
	if m.FilePart != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.FilePart))
		i--
		dAtA[i] = 0x28
	}
	if m.FileId != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.FileId))
		i--
		dAtA[i] = 0x20
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadPhotoFileV2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadProfilePhotoFileV2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.VideoStartTs != nil {
		{
			size, err := m.VideoStartTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Video != nil {
		{
			size, err := m.Video.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadEncryptedFileV2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsDownloadFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Limit != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x28
	}
	if m.Offset != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x20
	}
	if m.Location != nil {
		{
			size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadDocumentFileV2) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Media != nil {
		{
			size, err := m.Media.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadGifDocumentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Media != nil {
		{
			size, err := m.Media.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadMp4DocumentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Media != nil {
		{
			size, err := m.Media.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadWallPaperFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Admin != nil {
		{
			size, err := m.Admin.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.MimeType) > 0 {
		i -= len(m.MimeType)
		copy(dAtA[i:], m.MimeType)
		i = encodeVarintDfsTl(dAtA, i, uint64(len(m.MimeType)))
		i--
		dAtA[i] = 0x2a
	}
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadThemeFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.FileName) > 0 {
		i -= len(m.FileName)
		copy(dAtA[i:], m.FileName)
		i = encodeVarintDfsTl(dAtA, i, uint64(len(m.FileName)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.MimeType) > 0 {
		i -= len(m.MimeType)
		copy(dAtA[i:], m.MimeType)
		i = encodeVarintDfsTl(dAtA, i, uint64(len(m.MimeType)))
		i--
		dAtA[i] = 0x32
	}
	if m.Thumb != nil {
		{
			size, err := m.Thumb.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *TLDfsUploadRingtoneFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.FileName) > 0 {
		i -= len(m.FileName)
		copy(dAtA[i:], m.FileName)
		i = encodeVarintDfsTl(dAtA, i, uint64(len(m.FileName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.MimeType) > 0 {
		i -= len(m.MimeType)
		copy(dAtA[i:], m.MimeType)
		i = encodeVarintDfsTl(dAtA, i, uint64(len(m.MimeType)))
		i--
		dAtA[i] = 0x2a
	}
	if m.File != nil {
		{
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDfsTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Creator != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Creator))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintDfsTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintDfsTl(dAtA []byte, offset int, v uint64) int {
	offset -= sovDfsTl(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TLDfsWriteFilePartData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.FileId != 0 {
		n += 1 + sovDfsTl(uint64(m.FileId))
	}
	if m.FilePart != 0 {
		n += 1 + sovDfsTl(uint64(m.FilePart))
	}
	l = len(m.Bytes)
	if l > 0 {
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.Big {
		n += 2
	}
	if m.FileTotalParts != nil {
		l = m.FileTotalParts.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadPhotoFileV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadProfilePhotoFileV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.Video != nil {
		l = m.Video.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.VideoStartTs != nil {
		l = m.VideoStartTs.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadEncryptedFileV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsDownloadFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Location != nil {
		l = m.Location.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovDfsTl(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovDfsTl(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadDocumentFileV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.Media != nil {
		l = m.Media.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadGifDocumentMedia) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.Media != nil {
		l = m.Media.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadMp4DocumentMedia) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.Media != nil {
		l = m.Media.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadWallPaperFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	l = len(m.MimeType)
	if l > 0 {
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.Admin != nil {
		l = m.Admin.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadThemeFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.Thumb != nil {
		l = m.Thumb.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	l = len(m.MimeType)
	if l > 0 {
		n += 1 + l + sovDfsTl(uint64(l))
	}
	l = len(m.FileName)
	if l > 0 {
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLDfsUploadRingtoneFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovDfsTl(uint64(m.Constructor))
	}
	if m.Creator != 0 {
		n += 1 + sovDfsTl(uint64(m.Creator))
	}
	if m.File != nil {
		l = m.File.Size()
		n += 1 + l + sovDfsTl(uint64(l))
	}
	l = len(m.MimeType)
	if l > 0 {
		n += 1 + l + sovDfsTl(uint64(l))
	}
	l = len(m.FileName)
	if l > 0 {
		n += 1 + l + sovDfsTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovDfsTl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDfsTl(x uint64) (n int) {
	return sovDfsTl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TLDfsWriteFilePartData) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_writeFilePartData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_writeFilePartData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileId", wireType)
			}
			m.FileId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FileId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilePart", wireType)
			}
			m.FilePart = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FilePart |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bytes = append(m.Bytes[:0], dAtA[iNdEx:postIndex]...)
			if m.Bytes == nil {
				m.Bytes = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Big", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Big = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileTotalParts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FileTotalParts == nil {
				m.FileTotalParts = &types.Int32Value{}
			}
			if err := m.FileTotalParts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadPhotoFileV2) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadPhotoFileV2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadPhotoFileV2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.File == nil {
				m.File = &mtproto.InputFile{}
			}
			if err := m.File.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadProfilePhotoFileV2) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadProfilePhotoFileV2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadProfilePhotoFileV2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.File == nil {
				m.File = &mtproto.InputFile{}
			}
			if err := m.File.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Video", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Video == nil {
				m.Video = &mtproto.InputFile{}
			}
			if err := m.Video.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VideoStartTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VideoStartTs == nil {
				m.VideoStartTs = &types.DoubleValue{}
			}
			if err := m.VideoStartTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadEncryptedFileV2) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadEncryptedFileV2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadEncryptedFileV2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.File == nil {
				m.File = &mtproto.InputEncryptedFile{}
			}
			if err := m.File.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsDownloadFile) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_downloadFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_downloadFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Location == nil {
				m.Location = &mtproto.InputFileLocation{}
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadDocumentFileV2) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadDocumentFileV2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadDocumentFileV2: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Media", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Media == nil {
				m.Media = &mtproto.InputMedia{}
			}
			if err := m.Media.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadGifDocumentMedia) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadGifDocumentMedia: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadGifDocumentMedia: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Media", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Media == nil {
				m.Media = &mtproto.InputMedia{}
			}
			if err := m.Media.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadMp4DocumentMedia) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadMp4DocumentMedia: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadMp4DocumentMedia: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Media", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Media == nil {
				m.Media = &mtproto.InputMedia{}
			}
			if err := m.Media.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadWallPaperFile) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadWallPaperFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadWallPaperFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.File == nil {
				m.File = &mtproto.InputFile{}
			}
			if err := m.File.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MimeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				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 ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MimeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Admin == nil {
				m.Admin = &mtproto.Bool{}
			}
			if err := m.Admin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadThemeFile) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadThemeFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadThemeFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.File == nil {
				m.File = &mtproto.InputFile{}
			}
			if err := m.File.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Thumb", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Thumb == nil {
				m.Thumb = &mtproto.InputFile{}
			}
			if err := m.Thumb.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MimeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				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 ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MimeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				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 ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLDfsUploadRingtoneFile) 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 ErrIntOverflowDfsTl
			}
			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: TL_dfs_uploadRingtoneFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_dfs_uploadRingtoneFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			m.Creator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Creator |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.File == nil {
				m.File = &mtproto.InputFile{}
			}
			if err := m.File.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MimeType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				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 ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MimeType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDfsTl
				}
				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 ErrInvalidLengthDfsTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDfsTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDfsTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDfsTl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthDfsTl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDfsTl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDfsTl = fmt.Errorf("proto: unexpected end of group")
)