sync.tl.pb.go

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

package sync

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_sync_updatesMe        TLConstructor = 1614568688
	CRC32_sync_updatesNotMe     TLConstructor = 16458447
	CRC32_sync_pushUpdates      TLConstructor = -1895114306
	CRC32_sync_pushUpdatesIfNot TLConstructor = 1074085860
	CRC32_sync_pushBotUpdates   TLConstructor = -1379667968
	CRC32_sync_pushRpcResult    TLConstructor = -1874085983
	CRC32_sync_broadcastUpdates TLConstructor = -169648970
)

var TLConstructor_name = map[int32]string{
	0:           "CRC32_UNKNOWN",
	1614568688:  "CRC32_sync_updatesMe",
	16458447:    "CRC32_sync_updatesNotMe",
	-1895114306: "CRC32_sync_pushUpdates",
	1074085860:  "CRC32_sync_pushUpdatesIfNot",
	-1379667968: "CRC32_sync_pushBotUpdates",
	-1874085983: "CRC32_sync_pushRpcResult",
	-169648970:  "CRC32_sync_broadcastUpdates",
}

var TLConstructor_value = map[string]int32{
	"CRC32_UNKNOWN":               0,
	"CRC32_sync_updatesMe":        1614568688,
	"CRC32_sync_updatesNotMe":     16458447,
	"CRC32_sync_pushUpdates":      -1895114306,
	"CRC32_sync_pushUpdatesIfNot": 1074085860,
	"CRC32_sync_pushBotUpdates":   -1379667968,
	"CRC32_sync_pushRpcResult":    -1874085983,
	"CRC32_sync_broadcastUpdates": -169648970,
}

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

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

//--------------------------------------------------------------------------------------------
// sync.updatesMe flags:# user_id:long auth_key_id:long server_id:string session_id:flags.0?long updates:Updates = Void;
type TLSyncUpdatesMe struct {
	Constructor          TLConstructor     `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	UserId               int64             `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	AuthKeyId            int64             `protobuf:"varint,4,opt,name=auth_key_id,json=authKeyId,proto3" json:"auth_key_id,omitempty"`
	ServerId             string            `protobuf:"bytes,5,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	SessionId            *types.Int64Value `protobuf:"bytes,6,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	Updates              *mtproto.Updates  `protobuf:"bytes,7,opt,name=updates,proto3" json:"updates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_TLSyncUpdatesMe proto.InternalMessageInfo

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

func (m *TLSyncUpdatesMe) GetUserId() int64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *TLSyncUpdatesMe) GetAuthKeyId() int64 {
	if m != nil {
		return m.AuthKeyId
	}
	return 0
}

func (m *TLSyncUpdatesMe) GetServerId() string {
	if m != nil {
		return m.ServerId
	}
	return ""
}

func (m *TLSyncUpdatesMe) GetSessionId() *types.Int64Value {
	if m != nil {
		return m.SessionId
	}
	return nil
}

func (m *TLSyncUpdatesMe) GetUpdates() *mtproto.Updates {
	if m != nil {
		return m.Updates
	}
	return nil
}

//--------------------------------------------------------------------------------------------
// sync.updatesNotMe user_id:long auth_key_id:long updates:Updates = Void;
type TLSyncUpdatesNotMe struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	UserId               int64            `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	AuthKeyId            int64            `protobuf:"varint,4,opt,name=auth_key_id,json=authKeyId,proto3" json:"auth_key_id,omitempty"`
	Updates              *mtproto.Updates `protobuf:"bytes,5,opt,name=updates,proto3" json:"updates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLSyncUpdatesNotMe proto.InternalMessageInfo

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

func (m *TLSyncUpdatesNotMe) GetUserId() int64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *TLSyncUpdatesNotMe) GetAuthKeyId() int64 {
	if m != nil {
		return m.AuthKeyId
	}
	return 0
}

func (m *TLSyncUpdatesNotMe) GetUpdates() *mtproto.Updates {
	if m != nil {
		return m.Updates
	}
	return nil
}

//--------------------------------------------------------------------------------------------
// sync.pushUpdates user_id:long updates:Updates = Void;
type TLSyncPushUpdates struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	UserId               int64            `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Updates              *mtproto.Updates `protobuf:"bytes,4,opt,name=updates,proto3" json:"updates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLSyncPushUpdates proto.InternalMessageInfo

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

func (m *TLSyncPushUpdates) GetUserId() int64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *TLSyncPushUpdates) GetUpdates() *mtproto.Updates {
	if m != nil {
		return m.Updates
	}
	return nil
}

//--------------------------------------------------------------------------------------------
// sync.pushUpdatesIfNot user_id:long excludes:Vector<long> updates:Updates = Void;
type TLSyncPushUpdatesIfNot struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	UserId               int64            `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Excludes             []int64          `protobuf:"varint,4,rep,packed,name=excludes,proto3" json:"excludes,omitempty"`
	Updates              *mtproto.Updates `protobuf:"bytes,5,opt,name=updates,proto3" json:"updates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLSyncPushUpdatesIfNot proto.InternalMessageInfo

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

func (m *TLSyncPushUpdatesIfNot) GetUserId() int64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *TLSyncPushUpdatesIfNot) GetExcludes() []int64 {
	if m != nil {
		return m.Excludes
	}
	return nil
}

func (m *TLSyncPushUpdatesIfNot) GetUpdates() *mtproto.Updates {
	if m != nil {
		return m.Updates
	}
	return nil
}

//--------------------------------------------------------------------------------------------
// sync.pushBotUpdates user_id:long updates:Updates = Void;
type TLSyncPushBotUpdates struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	UserId               int64            `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Updates              *mtproto.Updates `protobuf:"bytes,4,opt,name=updates,proto3" json:"updates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLSyncPushBotUpdates proto.InternalMessageInfo

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

func (m *TLSyncPushBotUpdates) GetUserId() int64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *TLSyncPushBotUpdates) GetUpdates() *mtproto.Updates {
	if m != nil {
		return m.Updates
	}
	return nil
}

//--------------------------------------------------------------------------------------------
// sync.pushRpcResult auth_key_id:long server_id:string session_id:long client_req_msg_id:long rpc_result:bytes = Void;
type TLSyncPushRpcResult struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	AuthKeyId            int64         `protobuf:"varint,3,opt,name=auth_key_id,json=authKeyId,proto3" json:"auth_key_id,omitempty"`
	ServerId             string        `protobuf:"bytes,4,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	SessionId            int64         `protobuf:"varint,5,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	ClientReqMsgId       int64         `protobuf:"varint,6,opt,name=client_req_msg_id,json=clientReqMsgId,proto3" json:"client_req_msg_id,omitempty"`
	RpcResult            []byte        `protobuf:"bytes,7,opt,name=rpc_result,json=rpcResult,proto3" json:"rpc_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLSyncPushRpcResult proto.InternalMessageInfo

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

func (m *TLSyncPushRpcResult) GetAuthKeyId() int64 {
	if m != nil {
		return m.AuthKeyId
	}
	return 0
}

func (m *TLSyncPushRpcResult) GetServerId() string {
	if m != nil {
		return m.ServerId
	}
	return ""
}

func (m *TLSyncPushRpcResult) GetSessionId() int64 {
	if m != nil {
		return m.SessionId
	}
	return 0
}

func (m *TLSyncPushRpcResult) GetClientReqMsgId() int64 {
	if m != nil {
		return m.ClientReqMsgId
	}
	return 0
}

func (m *TLSyncPushRpcResult) GetRpcResult() []byte {
	if m != nil {
		return m.RpcResult
	}
	return nil
}

//--------------------------------------------------------------------------------------------
// sync.broadcastUpdates broadcast_type:int chat_id:long exclude_id_list:Vector<long> updates:Updates = Void;
type TLSyncBroadcastUpdates struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=sync.TLConstructor" json:"constructor,omitempty"`
	BroadcastType        int32            `protobuf:"varint,3,opt,name=broadcast_type,json=broadcastType,proto3" json:"broadcast_type,omitempty"`
	ChatId               int64            `protobuf:"varint,4,opt,name=chat_id,json=chatId,proto3" json:"chat_id,omitempty"`
	ExcludeIdList        []int64          `protobuf:"varint,5,rep,packed,name=exclude_id_list,json=excludeIdList,proto3" json:"exclude_id_list,omitempty"`
	Updates              *mtproto.Updates `protobuf:"bytes,6,opt,name=updates,proto3" json:"updates,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLSyncBroadcastUpdates proto.InternalMessageInfo

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

func (m *TLSyncBroadcastUpdates) GetBroadcastType() int32 {
	if m != nil {
		return m.BroadcastType
	}
	return 0
}

func (m *TLSyncBroadcastUpdates) GetChatId() int64 {
	if m != nil {
		return m.ChatId
	}
	return 0
}

func (m *TLSyncBroadcastUpdates) GetExcludeIdList() []int64 {
	if m != nil {
		return m.ExcludeIdList
	}
	return nil
}

func (m *TLSyncBroadcastUpdates) GetUpdates() *mtproto.Updates {
	if m != nil {
		return m.Updates
	}
	return nil
}

func init() {
	proto.RegisterEnum("sync.TLConstructor", TLConstructor_name, TLConstructor_value)
	proto.RegisterType((*TLSyncUpdatesMe)(nil), "sync.TL_sync_updatesMe")
	proto.RegisterType((*TLSyncUpdatesNotMe)(nil), "sync.TL_sync_updatesNotMe")
	proto.RegisterType((*TLSyncPushUpdates)(nil), "sync.TL_sync_pushUpdates")
	proto.RegisterType((*TLSyncPushUpdatesIfNot)(nil), "sync.TL_sync_pushUpdatesIfNot")
	proto.RegisterType((*TLSyncPushBotUpdates)(nil), "sync.TL_sync_pushBotUpdates")
	proto.RegisterType((*TLSyncPushRpcResult)(nil), "sync.TL_sync_pushRpcResult")
	proto.RegisterType((*TLSyncBroadcastUpdates)(nil), "sync.TL_sync_broadcastUpdates")
}

func init() { proto.RegisterFile("sync.tl.proto", fileDescriptor_04d9f5ff30041e30) }

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

func (this *TLSyncUpdatesMe) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&sync.TLSyncUpdatesMe{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "AuthKeyId: "+fmt.Sprintf("%#v", this.AuthKeyId)+",\n")
	s = append(s, "ServerId: "+fmt.Sprintf("%#v", this.ServerId)+",\n")
	if this.SessionId != nil {
		s = append(s, "SessionId: "+fmt.Sprintf("%#v", this.SessionId)+",\n")
	}
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\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 *TLSyncUpdatesNotMe) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&sync.TLSyncUpdatesNotMe{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "AuthKeyId: "+fmt.Sprintf("%#v", this.AuthKeyId)+",\n")
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\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 *TLSyncPushUpdates) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&sync.TLSyncPushUpdates{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\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 *TLSyncPushUpdatesIfNot) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&sync.TLSyncPushUpdatesIfNot{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "Excludes: "+fmt.Sprintf("%#v", this.Excludes)+",\n")
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\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 *TLSyncPushBotUpdates) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&sync.TLSyncPushBotUpdates{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\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 *TLSyncPushRpcResult) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&sync.TLSyncPushRpcResult{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "AuthKeyId: "+fmt.Sprintf("%#v", this.AuthKeyId)+",\n")
	s = append(s, "ServerId: "+fmt.Sprintf("%#v", this.ServerId)+",\n")
	s = append(s, "SessionId: "+fmt.Sprintf("%#v", this.SessionId)+",\n")
	s = append(s, "ClientReqMsgId: "+fmt.Sprintf("%#v", this.ClientReqMsgId)+",\n")
	s = append(s, "RpcResult: "+fmt.Sprintf("%#v", this.RpcResult)+",\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 *TLSyncBroadcastUpdates) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&sync.TLSyncBroadcastUpdates{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "BroadcastType: "+fmt.Sprintf("%#v", this.BroadcastType)+",\n")
	s = append(s, "ChatId: "+fmt.Sprintf("%#v", this.ChatId)+",\n")
	s = append(s, "ExcludeIdList: "+fmt.Sprintf("%#v", this.ExcludeIdList)+",\n")
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\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 valueToGoStringSyncTl(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

// RPCSyncClient is the client API for RPCSync service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RPCSyncClient interface {
	// sync.updatesMe flags:# user_id:long auth_key_id:long server_id:string session_id:flags.0?long updates:Updates = Void;
	SyncUpdatesMe(ctx context.Context, in *TLSyncUpdatesMe, opts ...grpc.CallOption) (*mtproto.Void, error)
	// sync.updatesNotMe user_id:long auth_key_id:long updates:Updates = Void;
	SyncUpdatesNotMe(ctx context.Context, in *TLSyncUpdatesNotMe, opts ...grpc.CallOption) (*mtproto.Void, error)
	// sync.pushUpdates user_id:long updates:Updates = Void;
	SyncPushUpdates(ctx context.Context, in *TLSyncPushUpdates, opts ...grpc.CallOption) (*mtproto.Void, error)
	// sync.pushUpdatesIfNot user_id:long excludes:Vector<long> updates:Updates = Void;
	SyncPushUpdatesIfNot(ctx context.Context, in *TLSyncPushUpdatesIfNot, opts ...grpc.CallOption) (*mtproto.Void, error)
	// sync.pushBotUpdates user_id:long updates:Updates = Void;
	SyncPushBotUpdates(ctx context.Context, in *TLSyncPushBotUpdates, opts ...grpc.CallOption) (*mtproto.Void, error)
	// sync.pushRpcResult auth_key_id:long server_id:string session_id:long client_req_msg_id:long rpc_result:bytes = Void;
	SyncPushRpcResult(ctx context.Context, in *TLSyncPushRpcResult, opts ...grpc.CallOption) (*mtproto.Void, error)
	// sync.broadcastUpdates broadcast_type:int chat_id:long exclude_id_list:Vector<long> updates:Updates = Void;
	SyncBroadcastUpdates(ctx context.Context, in *TLSyncBroadcastUpdates, opts ...grpc.CallOption) (*mtproto.Void, error)
}

type rPCSyncClient struct {
	cc *grpc.ClientConn
}

func NewRPCSyncClient(cc *grpc.ClientConn) RPCSyncClient {
	return &rPCSyncClient{cc}
}

func (c *rPCSyncClient) SyncUpdatesMe(ctx context.Context, in *TLSyncUpdatesMe, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_updatesMe", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCSyncClient) SyncUpdatesNotMe(ctx context.Context, in *TLSyncUpdatesNotMe, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_updatesNotMe", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCSyncClient) SyncPushUpdates(ctx context.Context, in *TLSyncPushUpdates, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_pushUpdates", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCSyncClient) SyncPushUpdatesIfNot(ctx context.Context, in *TLSyncPushUpdatesIfNot, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_pushUpdatesIfNot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCSyncClient) SyncPushBotUpdates(ctx context.Context, in *TLSyncPushBotUpdates, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_pushBotUpdates", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCSyncClient) SyncPushRpcResult(ctx context.Context, in *TLSyncPushRpcResult, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_pushRpcResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCSyncClient) SyncBroadcastUpdates(ctx context.Context, in *TLSyncBroadcastUpdates, opts ...grpc.CallOption) (*mtproto.Void, error) {
	out := new(mtproto.Void)
	err := c.cc.Invoke(ctx, "/sync.RPCSync/sync_broadcastUpdates", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RPCSyncServer is the server API for RPCSync service.
type RPCSyncServer interface {
	// sync.updatesMe flags:# user_id:long auth_key_id:long server_id:string session_id:flags.0?long updates:Updates = Void;
	SyncUpdatesMe(context.Context, *TLSyncUpdatesMe) (*mtproto.Void, error)
	// sync.updatesNotMe user_id:long auth_key_id:long updates:Updates = Void;
	SyncUpdatesNotMe(context.Context, *TLSyncUpdatesNotMe) (*mtproto.Void, error)
	// sync.pushUpdates user_id:long updates:Updates = Void;
	SyncPushUpdates(context.Context, *TLSyncPushUpdates) (*mtproto.Void, error)
	// sync.pushUpdatesIfNot user_id:long excludes:Vector<long> updates:Updates = Void;
	SyncPushUpdatesIfNot(context.Context, *TLSyncPushUpdatesIfNot) (*mtproto.Void, error)
	// sync.pushBotUpdates user_id:long updates:Updates = Void;
	SyncPushBotUpdates(context.Context, *TLSyncPushBotUpdates) (*mtproto.Void, error)
	// sync.pushRpcResult auth_key_id:long server_id:string session_id:long client_req_msg_id:long rpc_result:bytes = Void;
	SyncPushRpcResult(context.Context, *TLSyncPushRpcResult) (*mtproto.Void, error)
	// sync.broadcastUpdates broadcast_type:int chat_id:long exclude_id_list:Vector<long> updates:Updates = Void;
	SyncBroadcastUpdates(context.Context, *TLSyncBroadcastUpdates) (*mtproto.Void, error)
}

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

func (*UnimplementedRPCSyncServer) SyncUpdatesMe(ctx context.Context, req *TLSyncUpdatesMe) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncUpdatesMe not implemented")
}
func (*UnimplementedRPCSyncServer) SyncUpdatesNotMe(ctx context.Context, req *TLSyncUpdatesNotMe) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncUpdatesNotMe not implemented")
}
func (*UnimplementedRPCSyncServer) SyncPushUpdates(ctx context.Context, req *TLSyncPushUpdates) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncPushUpdates not implemented")
}
func (*UnimplementedRPCSyncServer) SyncPushUpdatesIfNot(ctx context.Context, req *TLSyncPushUpdatesIfNot) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncPushUpdatesIfNot not implemented")
}
func (*UnimplementedRPCSyncServer) SyncPushBotUpdates(ctx context.Context, req *TLSyncPushBotUpdates) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncPushBotUpdates not implemented")
}
func (*UnimplementedRPCSyncServer) SyncPushRpcResult(ctx context.Context, req *TLSyncPushRpcResult) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncPushRpcResult not implemented")
}
func (*UnimplementedRPCSyncServer) SyncBroadcastUpdates(ctx context.Context, req *TLSyncBroadcastUpdates) (*mtproto.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncBroadcastUpdates not implemented")
}

func RegisterRPCSyncServer(s *grpc.Server, srv RPCSyncServer) {
	s.RegisterService(&_RPCSync_serviceDesc, srv)
}

func _RPCSync_SyncUpdatesMe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncUpdatesMe)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncUpdatesMe(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncUpdatesMe",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncUpdatesMe(ctx, req.(*TLSyncUpdatesMe))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCSync_SyncUpdatesNotMe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncUpdatesNotMe)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncUpdatesNotMe(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncUpdatesNotMe",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncUpdatesNotMe(ctx, req.(*TLSyncUpdatesNotMe))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCSync_SyncPushUpdates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncPushUpdates)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncPushUpdates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncPushUpdates",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncPushUpdates(ctx, req.(*TLSyncPushUpdates))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCSync_SyncPushUpdatesIfNot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncPushUpdatesIfNot)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncPushUpdatesIfNot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncPushUpdatesIfNot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncPushUpdatesIfNot(ctx, req.(*TLSyncPushUpdatesIfNot))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCSync_SyncPushBotUpdates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncPushBotUpdates)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncPushBotUpdates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncPushBotUpdates",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncPushBotUpdates(ctx, req.(*TLSyncPushBotUpdates))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCSync_SyncPushRpcResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncPushRpcResult)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncPushRpcResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncPushRpcResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncPushRpcResult(ctx, req.(*TLSyncPushRpcResult))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCSync_SyncBroadcastUpdates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLSyncBroadcastUpdates)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCSyncServer).SyncBroadcastUpdates(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/sync.RPCSync/SyncBroadcastUpdates",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCSyncServer).SyncBroadcastUpdates(ctx, req.(*TLSyncBroadcastUpdates))
	}
	return interceptor(ctx, in, info, handler)
}

var _RPCSync_serviceDesc = grpc.ServiceDesc{
	ServiceName: "sync.RPCSync",
	HandlerType: (*RPCSyncServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "sync_updatesMe",
			Handler:    _RPCSync_SyncUpdatesMe_Handler,
		},
		{
			MethodName: "sync_updatesNotMe",
			Handler:    _RPCSync_SyncUpdatesNotMe_Handler,
		},
		{
			MethodName: "sync_pushUpdates",
			Handler:    _RPCSync_SyncPushUpdates_Handler,
		},
		{
			MethodName: "sync_pushUpdatesIfNot",
			Handler:    _RPCSync_SyncPushUpdatesIfNot_Handler,
		},
		{
			MethodName: "sync_pushBotUpdates",
			Handler:    _RPCSync_SyncPushBotUpdates_Handler,
		},
		{
			MethodName: "sync_pushRpcResult",
			Handler:    _RPCSync_SyncPushRpcResult_Handler,
		},
		{
			MethodName: "sync_broadcastUpdates",
			Handler:    _RPCSync_SyncBroadcastUpdates_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "sync.tl.proto",
}

func (m *TLSyncUpdatesMe) 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 *TLSyncUpdatesMe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncUpdatesMe) 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.Updates != nil {
		{
			size, err := m.Updates.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.SessionId != nil {
		{
			size, err := m.SessionId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.ServerId) > 0 {
		i -= len(m.ServerId)
		copy(dAtA[i:], m.ServerId)
		i = encodeVarintSyncTl(dAtA, i, uint64(len(m.ServerId)))
		i--
		dAtA[i] = 0x2a
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSyncUpdatesNotMe) 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 *TLSyncUpdatesNotMe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncUpdatesNotMe) 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.Updates != nil {
		{
			size, err := m.Updates.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSyncPushUpdates) 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 *TLSyncPushUpdates) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncPushUpdates) 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.Updates != nil {
		{
			size, err := m.Updates.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSyncPushUpdatesIfNot) 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 *TLSyncPushUpdatesIfNot) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncPushUpdatesIfNot) 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.Updates != nil {
		{
			size, err := m.Updates.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Excludes) > 0 {
		dAtA7 := make([]byte, len(m.Excludes)*10)
		var j6 int
		for _, num1 := range m.Excludes {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		i -= j6
		copy(dAtA[i:], dAtA7[:j6])
		i = encodeVarintSyncTl(dAtA, i, uint64(j6))
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSyncPushBotUpdates) 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 *TLSyncPushBotUpdates) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncPushBotUpdates) 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.Updates != nil {
		{
			size, err := m.Updates.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSyncPushRpcResult) 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 *TLSyncPushRpcResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncPushRpcResult) 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.RpcResult) > 0 {
		i -= len(m.RpcResult)
		copy(dAtA[i:], m.RpcResult)
		i = encodeVarintSyncTl(dAtA, i, uint64(len(m.RpcResult)))
		i--
		dAtA[i] = 0x3a
	}
	if m.ClientReqMsgId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.ClientReqMsgId))
		i--
		dAtA[i] = 0x30
	}
	if m.SessionId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.SessionId))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ServerId) > 0 {
		i -= len(m.ServerId)
		copy(dAtA[i:], m.ServerId)
		i = encodeVarintSyncTl(dAtA, i, uint64(len(m.ServerId)))
		i--
		dAtA[i] = 0x22
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSyncBroadcastUpdates) 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 *TLSyncBroadcastUpdates) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSyncBroadcastUpdates) 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.Updates != nil {
		{
			size, err := m.Updates.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSyncTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.ExcludeIdList) > 0 {
		dAtA11 := make([]byte, len(m.ExcludeIdList)*10)
		var j10 int
		for _, num1 := range m.ExcludeIdList {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		i -= j10
		copy(dAtA[i:], dAtA11[:j10])
		i = encodeVarintSyncTl(dAtA, i, uint64(j10))
		i--
		dAtA[i] = 0x2a
	}
	if m.ChatId != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.ChatId))
		i--
		dAtA[i] = 0x20
	}
	if m.BroadcastType != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.BroadcastType))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintSyncTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintSyncTl(dAtA []byte, offset int, v uint64) int {
	offset -= sovSyncTl(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TLSyncUpdatesMe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovSyncTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovSyncTl(uint64(m.AuthKeyId))
	}
	l = len(m.ServerId)
	if l > 0 {
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.SessionId != nil {
		l = m.SessionId.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.Updates != nil {
		l = m.Updates.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSyncUpdatesNotMe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovSyncTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovSyncTl(uint64(m.AuthKeyId))
	}
	if m.Updates != nil {
		l = m.Updates.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSyncPushUpdates) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovSyncTl(uint64(m.UserId))
	}
	if m.Updates != nil {
		l = m.Updates.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSyncPushUpdatesIfNot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovSyncTl(uint64(m.UserId))
	}
	if len(m.Excludes) > 0 {
		l = 0
		for _, e := range m.Excludes {
			l += sovSyncTl(uint64(e))
		}
		n += 1 + sovSyncTl(uint64(l)) + l
	}
	if m.Updates != nil {
		l = m.Updates.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSyncPushBotUpdates) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovSyncTl(uint64(m.UserId))
	}
	if m.Updates != nil {
		l = m.Updates.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSyncPushRpcResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovSyncTl(uint64(m.AuthKeyId))
	}
	l = len(m.ServerId)
	if l > 0 {
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.SessionId != 0 {
		n += 1 + sovSyncTl(uint64(m.SessionId))
	}
	if m.ClientReqMsgId != 0 {
		n += 1 + sovSyncTl(uint64(m.ClientReqMsgId))
	}
	l = len(m.RpcResult)
	if l > 0 {
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSyncBroadcastUpdates) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovSyncTl(uint64(m.Constructor))
	}
	if m.BroadcastType != 0 {
		n += 1 + sovSyncTl(uint64(m.BroadcastType))
	}
	if m.ChatId != 0 {
		n += 1 + sovSyncTl(uint64(m.ChatId))
	}
	if len(m.ExcludeIdList) > 0 {
		l = 0
		for _, e := range m.ExcludeIdList {
			l += sovSyncTl(uint64(e))
		}
		n += 1 + sovSyncTl(uint64(l)) + l
	}
	if m.Updates != nil {
		l = m.Updates.Size()
		n += 1 + l + sovSyncTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovSyncTl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSyncTl(x uint64) (n int) {
	return sovSyncTl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TLSyncUpdatesMe) 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 ErrIntOverflowSyncTl
			}
			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_sync_updatesMe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_updatesMe: 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 ErrIntOverflowSyncTl
				}
				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 UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthKeyId", wireType)
			}
			m.AuthKeyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				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 ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SessionId == nil {
				m.SessionId = &types.Int64Value{}
			}
			if err := m.SessionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updates == nil {
				m.Updates = &mtproto.Updates{}
			}
			if err := m.Updates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 *TLSyncUpdatesNotMe) 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 ErrIntOverflowSyncTl
			}
			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_sync_updatesNotMe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_updatesNotMe: 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 ErrIntOverflowSyncTl
				}
				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 UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthKeyId", wireType)
			}
			m.AuthKeyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updates == nil {
				m.Updates = &mtproto.Updates{}
			}
			if err := m.Updates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 *TLSyncPushUpdates) 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 ErrIntOverflowSyncTl
			}
			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_sync_pushUpdates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_pushUpdates: 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 ErrIntOverflowSyncTl
				}
				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 UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updates == nil {
				m.Updates = &mtproto.Updates{}
			}
			if err := m.Updates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 *TLSyncPushUpdatesIfNot) 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 ErrIntOverflowSyncTl
			}
			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_sync_pushUpdatesIfNot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_pushUpdatesIfNot: 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 ErrIntOverflowSyncTl
				}
				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 UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSyncTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Excludes = append(m.Excludes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSyncTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSyncTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSyncTl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Excludes) == 0 {
					m.Excludes = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSyncTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Excludes = append(m.Excludes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Excludes", wireType)
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updates == nil {
				m.Updates = &mtproto.Updates{}
			}
			if err := m.Updates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 *TLSyncPushBotUpdates) 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 ErrIntOverflowSyncTl
			}
			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_sync_pushBotUpdates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_pushBotUpdates: 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 ErrIntOverflowSyncTl
				}
				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 UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updates == nil {
				m.Updates = &mtproto.Updates{}
			}
			if err := m.Updates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 *TLSyncPushRpcResult) 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 ErrIntOverflowSyncTl
			}
			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_sync_pushRpcResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_pushRpcResult: 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 ErrIntOverflowSyncTl
				}
				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 AuthKeyId", wireType)
			}
			m.AuthKeyId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				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 ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionId", wireType)
			}
			m.SessionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SessionId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientReqMsgId", wireType)
			}
			m.ClientReqMsgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClientReqMsgId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RpcResult", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RpcResult = append(m.RpcResult[:0], dAtA[iNdEx:postIndex]...)
			if m.RpcResult == nil {
				m.RpcResult = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 *TLSyncBroadcastUpdates) 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 ErrIntOverflowSyncTl
			}
			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_sync_broadcastUpdates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sync_broadcastUpdates: 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 ErrIntOverflowSyncTl
				}
				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 BroadcastType", wireType)
			}
			m.BroadcastType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BroadcastType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChatId", wireType)
			}
			m.ChatId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChatId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSyncTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ExcludeIdList = append(m.ExcludeIdList, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSyncTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSyncTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSyncTl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ExcludeIdList) == 0 {
					m.ExcludeIdList = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSyncTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ExcludeIdList = append(m.ExcludeIdList, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ExcludeIdList", wireType)
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSyncTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSyncTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSyncTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updates == nil {
				m.Updates = &mtproto.Updates{}
			}
			if err := m.Updates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSyncTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSyncTl
			}
			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 skipSyncTl(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, ErrIntOverflowSyncTl
			}
			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, ErrIntOverflowSyncTl
				}
				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, ErrIntOverflowSyncTl
				}
				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, ErrInvalidLengthSyncTl
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupSyncTl
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthSyncTl
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthSyncTl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSyncTl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSyncTl = fmt.Errorf("proto: unexpected end of group")
)