msg.tl.pb.go

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

package msg

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_sender                     TLConstructor = 1513645242
	CRC32_outboxMessage              TLConstructor = 1402283185
	CRC32_contentMessage             TLConstructor = -1301595468
	CRC32_msg_sendMessage            TLConstructor = 1218652155
	CRC32_msg_sendMultiMessage       TLConstructor = -1727589428
	CRC32_msg_pushUserMessage        TLConstructor = 902887962
	CRC32_msg_readMessageContents    TLConstructor = 673481940
	CRC32_msg_sendMessageV2          TLConstructor = 770211174
	CRC32_msg_editMessage            TLConstructor = -2129725231
	CRC32_msg_deleteMessages         TLConstructor = 568855069
	CRC32_msg_deleteHistory          TLConstructor = 1975576778
	CRC32_msg_deletePhoneCallHistory TLConstructor = 649568574
	CRC32_msg_deleteChatHistory      TLConstructor = -283155749
	CRC32_msg_readHistory            TLConstructor = 1510960658
	CRC32_msg_updatePinnedMessage    TLConstructor = -441560663
	CRC32_msg_unpinAllMessages       TLConstructor = -1199153371
)

var TLConstructor_name = map[int32]string{
	0:           "CRC32_UNKNOWN",
	1513645242:  "CRC32_sender",
	1402283185:  "CRC32_outboxMessage",
	-1301595468: "CRC32_contentMessage",
	1218652155:  "CRC32_msg_sendMessage",
	-1727589428: "CRC32_msg_sendMultiMessage",
	902887962:   "CRC32_msg_pushUserMessage",
	673481940:   "CRC32_msg_readMessageContents",
	770211174:   "CRC32_msg_sendMessageV2",
	-2129725231: "CRC32_msg_editMessage",
	568855069:   "CRC32_msg_deleteMessages",
	1975576778:  "CRC32_msg_deleteHistory",
	649568574:   "CRC32_msg_deletePhoneCallHistory",
	-283155749:  "CRC32_msg_deleteChatHistory",
	1510960658:  "CRC32_msg_readHistory",
	-441560663:  "CRC32_msg_updatePinnedMessage",
	-1199153371: "CRC32_msg_unpinAllMessages",
}

var TLConstructor_value = map[string]int32{
	"CRC32_UNKNOWN":                    0,
	"CRC32_sender":                     1513645242,
	"CRC32_outboxMessage":              1402283185,
	"CRC32_contentMessage":             -1301595468,
	"CRC32_msg_sendMessage":            1218652155,
	"CRC32_msg_sendMultiMessage":       -1727589428,
	"CRC32_msg_pushUserMessage":        902887962,
	"CRC32_msg_readMessageContents":    673481940,
	"CRC32_msg_sendMessageV2":          770211174,
	"CRC32_msg_editMessage":            -2129725231,
	"CRC32_msg_deleteMessages":         568855069,
	"CRC32_msg_deleteHistory":          1975576778,
	"CRC32_msg_deletePhoneCallHistory": 649568574,
	"CRC32_msg_deleteChatHistory":      -283155749,
	"CRC32_msg_readHistory":            1510960658,
	"CRC32_msg_updatePinnedMessage":    -441560663,
	"CRC32_msg_unpinAllMessages":       -1199153371,
}

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

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

// ContentMessage <--
//  + TL_contentMessage
//
type ContentMessage struct {
	PredicateName        string        `protobuf:"bytes,1,opt,name=predicate_name,json=predicateName,proto3" json:"predicate_name,omitempty"`
	Constructor          TLConstructor `protobuf:"varint,2,opt,name=constructor,proto3,enum=msg.TLConstructor" json:"constructor,omitempty"`
	Id                   int32         `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"`
	DialogMessageId      int64         `protobuf:"varint,4,opt,name=dialog_message_id,json=dialogMessageId,proto3" json:"dialog_message_id,omitempty"`
	Mentioned            bool          `protobuf:"varint,5,opt,name=mentioned,proto3" json:"mentioned,omitempty"`
	MediaUnread          bool          `protobuf:"varint,6,opt,name=media_unread,json=mediaUnread,proto3" json:"media_unread,omitempty"`
	Reaction             bool          `protobuf:"varint,7,opt,name=reaction,proto3" json:"reaction,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_ContentMessage proto.InternalMessageInfo

func (m *ContentMessage) GetPredicateName() string {
	if m != nil {
		return m.PredicateName
	}
	return ""
}

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

func (m *ContentMessage) GetId() int32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *ContentMessage) GetDialogMessageId() int64 {
	if m != nil {
		return m.DialogMessageId
	}
	return 0
}

func (m *ContentMessage) GetMentioned() bool {
	if m != nil {
		return m.Mentioned
	}
	return false
}

func (m *ContentMessage) GetMediaUnread() bool {
	if m != nil {
		return m.MediaUnread
	}
	return false
}

func (m *ContentMessage) GetReaction() bool {
	if m != nil {
		return m.Reaction
	}
	return false
}

type TLContentMessage struct {
	Data2                *ContentMessage `protobuf:"bytes,1,opt,name=data2,proto3" json:"data2,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_TLContentMessage proto.InternalMessageInfo

func (m *TLContentMessage) GetData2() *ContentMessage {
	if m != nil {
		return m.Data2
	}
	return nil
}

// OutboxMessage <--
//  + TL_outboxMessage
//
type OutboxMessage struct {
	PredicateName        string            `protobuf:"bytes,1,opt,name=predicate_name,json=predicateName,proto3" json:"predicate_name,omitempty"`
	Constructor          TLConstructor     `protobuf:"varint,2,opt,name=constructor,proto3,enum=msg.TLConstructor" json:"constructor,omitempty"`
	NoWebpage            bool              `protobuf:"varint,3,opt,name=no_webpage,json=noWebpage,proto3" json:"no_webpage,omitempty"`
	Background           bool              `protobuf:"varint,4,opt,name=background,proto3" json:"background,omitempty"`
	RandomId             int64             `protobuf:"varint,5,opt,name=random_id,json=randomId,proto3" json:"random_id,omitempty"`
	Message              *mtproto.Message  `protobuf:"bytes,6,opt,name=message,proto3" json:"message,omitempty"`
	ScheduleDate         *types.Int32Value `protobuf:"bytes,7,opt,name=schedule_date,json=scheduleDate,proto3" json:"schedule_date,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_OutboxMessage proto.InternalMessageInfo

func (m *OutboxMessage) GetPredicateName() string {
	if m != nil {
		return m.PredicateName
	}
	return ""
}

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

func (m *OutboxMessage) GetNoWebpage() bool {
	if m != nil {
		return m.NoWebpage
	}
	return false
}

func (m *OutboxMessage) GetBackground() bool {
	if m != nil {
		return m.Background
	}
	return false
}

func (m *OutboxMessage) GetRandomId() int64 {
	if m != nil {
		return m.RandomId
	}
	return 0
}

func (m *OutboxMessage) GetMessage() *mtproto.Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *OutboxMessage) GetScheduleDate() *types.Int32Value {
	if m != nil {
		return m.ScheduleDate
	}
	return nil
}

type TLOutboxMessage struct {
	Data2                *OutboxMessage `protobuf:"bytes,1,opt,name=data2,proto3" json:"data2,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_TLOutboxMessage proto.InternalMessageInfo

func (m *TLOutboxMessage) GetData2() *OutboxMessage {
	if m != nil {
		return m.Data2
	}
	return nil
}

// Sender <--
//  + TL_sender
//
type Sender struct {
	PredicateName        string        `protobuf:"bytes,1,opt,name=predicate_name,json=predicateName,proto3" json:"predicate_name,omitempty"`
	Constructor          TLConstructor `protobuf:"varint,2,opt,name=constructor,proto3,enum=msg.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Type                 int32         `protobuf:"varint,4,opt,name=type,proto3" json:"type,omitempty"`
	AuthKeyId            int64         `protobuf:"varint,5,opt,name=auth_key_id,json=authKeyId,proto3" json:"auth_key_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Sender proto.InternalMessageInfo

func (m *Sender) GetPredicateName() string {
	if m != nil {
		return m.PredicateName
	}
	return ""
}

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

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

func (m *Sender) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

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

type TLSender struct {
	Data2                *Sender  `protobuf:"bytes,1,opt,name=data2,proto3" json:"data2,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TLSender proto.InternalMessageInfo

func (m *TLSender) GetData2() *Sender {
	if m != nil {
		return m.Data2
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgSendMessage struct {
	Constructor          TLConstructor  `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32          `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64          `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Message              *OutboxMessage `protobuf:"bytes,7,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_TLMsgSendMessage proto.InternalMessageInfo

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

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

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

func (m *TLMsgSendMessage) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgSendMessage) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgSendMessage) GetMessage() *OutboxMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgSendMultiMessage struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32            `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64            `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Message              []*OutboxMessage `protobuf:"bytes,7,rep,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLMsgSendMultiMessage proto.InternalMessageInfo

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

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

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

func (m *TLMsgSendMultiMessage) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgSendMultiMessage) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgSendMultiMessage) GetMessage() []*OutboxMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgPushUserMessage struct {
	Constructor          TLConstructor  `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32          `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64          `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	PushType             int32          `protobuf:"varint,7,opt,name=push_type,json=pushType,proto3" json:"push_type,omitempty"`
	Message              *OutboxMessage `protobuf:"bytes,8,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_TLMsgPushUserMessage proto.InternalMessageInfo

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

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

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

func (m *TLMsgPushUserMessage) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgPushUserMessage) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgPushUserMessage) GetPushType() int32 {
	if m != nil {
		return m.PushType
	}
	return 0
}

func (m *TLMsgPushUserMessage) GetMessage() *OutboxMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgReadMessageContents struct {
	Constructor          TLConstructor     `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32             `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64             `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Id                   []*ContentMessage `protobuf:"bytes,7,rep,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_TLMsgReadMessageContents proto.InternalMessageInfo

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

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

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

func (m *TLMsgReadMessageContents) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgReadMessageContents) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgReadMessageContents) GetId() []*ContentMessage {
	if m != nil {
		return m.Id
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgSendMessageV2 struct {
	Constructor          TLConstructor    `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32            `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64            `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Message              []*OutboxMessage `protobuf:"bytes,7,rep,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TLMsgSendMessageV2 proto.InternalMessageInfo

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

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

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

func (m *TLMsgSendMessageV2) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgSendMessageV2) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgSendMessageV2) GetMessage() []*OutboxMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgEditMessage struct {
	Constructor          TLConstructor  `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32          `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64          `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	EditType             int32          `protobuf:"varint,7,opt,name=edit_type,json=editType,proto3" json:"edit_type,omitempty"`
	Message              *OutboxMessage `protobuf:"bytes,8,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_TLMsgEditMessage proto.InternalMessageInfo

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

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

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

func (m *TLMsgEditMessage) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgEditMessage) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgEditMessage) GetEditType() int32 {
	if m != nil {
		return m.EditType
	}
	return 0
}

func (m *TLMsgEditMessage) GetMessage() *OutboxMessage {
	if m != nil {
		return m.Message
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgDeleteMessages struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32         `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Revoke               bool          `protobuf:"varint,7,opt,name=revoke,proto3" json:"revoke,omitempty"`
	Id                   []int32       `protobuf:"varint,8,rep,packed,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgDeleteMessages proto.InternalMessageInfo

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

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

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

func (m *TLMsgDeleteMessages) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgDeleteMessages) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgDeleteMessages) GetRevoke() bool {
	if m != nil {
		return m.Revoke
	}
	return false
}

func (m *TLMsgDeleteMessages) GetId() []int32 {
	if m != nil {
		return m.Id
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMsgDeleteHistory struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32         `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	JustClear            bool          `protobuf:"varint,7,opt,name=just_clear,json=justClear,proto3" json:"just_clear,omitempty"`
	Revoke               bool          `protobuf:"varint,8,opt,name=revoke,proto3" json:"revoke,omitempty"`
	MaxId                int32         `protobuf:"varint,9,opt,name=max_id,json=maxId,proto3" json:"max_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgDeleteHistory proto.InternalMessageInfo

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

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

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

func (m *TLMsgDeleteHistory) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgDeleteHistory) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgDeleteHistory) GetJustClear() bool {
	if m != nil {
		return m.JustClear
	}
	return false
}

func (m *TLMsgDeleteHistory) GetRevoke() bool {
	if m != nil {
		return m.Revoke
	}
	return false
}

func (m *TLMsgDeleteHistory) GetMaxId() int32 {
	if m != nil {
		return m.MaxId
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMsgDeletePhoneCallHistory struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	Revoke               bool          `protobuf:"varint,5,opt,name=revoke,proto3" json:"revoke,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgDeletePhoneCallHistory proto.InternalMessageInfo

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

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

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

func (m *TLMsgDeletePhoneCallHistory) GetRevoke() bool {
	if m != nil {
		return m.Revoke
	}
	return false
}

//--------------------------------------------------------------------------------------------
type TLMsgDeleteChatHistory struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.TLConstructor" json:"constructor,omitempty"`
	ChatId               int64         `protobuf:"varint,3,opt,name=chat_id,json=chatId,proto3" json:"chat_id,omitempty"`
	DeleteUserId         int64         `protobuf:"varint,4,opt,name=delete_user_id,json=deleteUserId,proto3" json:"delete_user_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgDeleteChatHistory proto.InternalMessageInfo

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

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

func (m *TLMsgDeleteChatHistory) GetDeleteUserId() int64 {
	if m != nil {
		return m.DeleteUserId
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMsgReadHistory struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32         `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	MaxId                int32         `protobuf:"varint,7,opt,name=max_id,json=maxId,proto3" json:"max_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgReadHistory proto.InternalMessageInfo

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

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

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

func (m *TLMsgReadHistory) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgReadHistory) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgReadHistory) GetMaxId() int32 {
	if m != nil {
		return m.MaxId
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMsgUpdatePinnedMessage struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	Silent               bool          `protobuf:"varint,5,opt,name=silent,proto3" json:"silent,omitempty"`
	Unpin                bool          `protobuf:"varint,6,opt,name=unpin,proto3" json:"unpin,omitempty"`
	PmOneside            bool          `protobuf:"varint,7,opt,name=pm_oneside,json=pmOneside,proto3" json:"pm_oneside,omitempty"`
	PeerType             int32         `protobuf:"varint,8,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,9,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Id                   int32         `protobuf:"varint,10,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgUpdatePinnedMessage proto.InternalMessageInfo

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

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

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

func (m *TLMsgUpdatePinnedMessage) GetSilent() bool {
	if m != nil {
		return m.Silent
	}
	return false
}

func (m *TLMsgUpdatePinnedMessage) GetUnpin() bool {
	if m != nil {
		return m.Unpin
	}
	return false
}

func (m *TLMsgUpdatePinnedMessage) GetPmOneside() bool {
	if m != nil {
		return m.PmOneside
	}
	return false
}

func (m *TLMsgUpdatePinnedMessage) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgUpdatePinnedMessage) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func (m *TLMsgUpdatePinnedMessage) GetId() int32 {
	if m != nil {
		return m.Id
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMsgUnpinAllMessages struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=msg.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"`
	PeerType             int32         `protobuf:"varint,5,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,6,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMsgUnpinAllMessages proto.InternalMessageInfo

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

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

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

func (m *TLMsgUnpinAllMessages) GetPeerType() int32 {
	if m != nil {
		return m.PeerType
	}
	return 0
}

func (m *TLMsgUnpinAllMessages) GetPeerId() int64 {
	if m != nil {
		return m.PeerId
	}
	return 0
}

func init() {
	proto.RegisterEnum("msg.TLConstructor", TLConstructor_name, TLConstructor_value)
	proto.RegisterType((*ContentMessage)(nil), "msg.ContentMessage")
	proto.RegisterType((*TLContentMessage)(nil), "msg.TL_contentMessage")
	proto.RegisterType((*OutboxMessage)(nil), "msg.OutboxMessage")
	proto.RegisterType((*TLOutboxMessage)(nil), "msg.TL_outboxMessage")
	proto.RegisterType((*Sender)(nil), "msg.Sender")
	proto.RegisterType((*TLSender)(nil), "msg.TL_sender")
	proto.RegisterType((*TLMsgSendMessage)(nil), "msg.TL_msg_sendMessage")
	proto.RegisterType((*TLMsgSendMultiMessage)(nil), "msg.TL_msg_sendMultiMessage")
	proto.RegisterType((*TLMsgPushUserMessage)(nil), "msg.TL_msg_pushUserMessage")
	proto.RegisterType((*TLMsgReadMessageContents)(nil), "msg.TL_msg_readMessageContents")
	proto.RegisterType((*TLMsgSendMessageV2)(nil), "msg.TL_msg_sendMessageV2")
	proto.RegisterType((*TLMsgEditMessage)(nil), "msg.TL_msg_editMessage")
	proto.RegisterType((*TLMsgDeleteMessages)(nil), "msg.TL_msg_deleteMessages")
	proto.RegisterType((*TLMsgDeleteHistory)(nil), "msg.TL_msg_deleteHistory")
	proto.RegisterType((*TLMsgDeletePhoneCallHistory)(nil), "msg.TL_msg_deletePhoneCallHistory")
	proto.RegisterType((*TLMsgDeleteChatHistory)(nil), "msg.TL_msg_deleteChatHistory")
	proto.RegisterType((*TLMsgReadHistory)(nil), "msg.TL_msg_readHistory")
	proto.RegisterType((*TLMsgUpdatePinnedMessage)(nil), "msg.TL_msg_updatePinnedMessage")
	proto.RegisterType((*TLMsgUnpinAllMessages)(nil), "msg.TL_msg_unpinAllMessages")
}

func init() { proto.RegisterFile("msg.tl.proto", fileDescriptor_cb6f24e718b1b713) }

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

func (this *ContentMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&msg.ContentMessage{")
	s = append(s, "PredicateName: "+fmt.Sprintf("%#v", this.PredicateName)+",\n")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "DialogMessageId: "+fmt.Sprintf("%#v", this.DialogMessageId)+",\n")
	s = append(s, "Mentioned: "+fmt.Sprintf("%#v", this.Mentioned)+",\n")
	s = append(s, "MediaUnread: "+fmt.Sprintf("%#v", this.MediaUnread)+",\n")
	s = append(s, "Reaction: "+fmt.Sprintf("%#v", this.Reaction)+",\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 *TLContentMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&msg.TLContentMessage{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\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 *OutboxMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&msg.OutboxMessage{")
	s = append(s, "PredicateName: "+fmt.Sprintf("%#v", this.PredicateName)+",\n")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "NoWebpage: "+fmt.Sprintf("%#v", this.NoWebpage)+",\n")
	s = append(s, "Background: "+fmt.Sprintf("%#v", this.Background)+",\n")
	s = append(s, "RandomId: "+fmt.Sprintf("%#v", this.RandomId)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	}
	if this.ScheduleDate != nil {
		s = append(s, "ScheduleDate: "+fmt.Sprintf("%#v", this.ScheduleDate)+",\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 *TLOutboxMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&msg.TLOutboxMessage{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\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 *Sender) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&msg.Sender{")
	s = append(s, "PredicateName: "+fmt.Sprintf("%#v", this.PredicateName)+",\n")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "AuthKeyId: "+fmt.Sprintf("%#v", this.AuthKeyId)+",\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 *TLSender) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&msg.TLSender{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\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 *TLMsgSendMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&msg.TLMsgSendMessage{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\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 *TLMsgSendMultiMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&msg.TLMsgSendMultiMessage{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\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 *TLMsgPushUserMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&msg.TLMsgPushUserMessage{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "PushType: "+fmt.Sprintf("%#v", this.PushType)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\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 *TLMsgReadMessageContents) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&msg.TLMsgReadMessageContents{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	if this.Id != nil {
		s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\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 *TLMsgSendMessageV2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&msg.TLMsgSendMessageV2{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\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 *TLMsgEditMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&msg.TLMsgEditMessage{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "EditType: "+fmt.Sprintf("%#v", this.EditType)+",\n")
	if this.Message != nil {
		s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\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 *TLMsgDeleteMessages) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&msg.TLMsgDeleteMessages{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "Revoke: "+fmt.Sprintf("%#v", this.Revoke)+",\n")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\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 *TLMsgDeleteHistory) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&msg.TLMsgDeleteHistory{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "JustClear: "+fmt.Sprintf("%#v", this.JustClear)+",\n")
	s = append(s, "Revoke: "+fmt.Sprintf("%#v", this.Revoke)+",\n")
	s = append(s, "MaxId: "+fmt.Sprintf("%#v", this.MaxId)+",\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 *TLMsgDeletePhoneCallHistory) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&msg.TLMsgDeletePhoneCallHistory{")
	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, "Revoke: "+fmt.Sprintf("%#v", this.Revoke)+",\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 *TLMsgDeleteChatHistory) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&msg.TLMsgDeleteChatHistory{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "ChatId: "+fmt.Sprintf("%#v", this.ChatId)+",\n")
	s = append(s, "DeleteUserId: "+fmt.Sprintf("%#v", this.DeleteUserId)+",\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 *TLMsgReadHistory) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&msg.TLMsgReadHistory{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "MaxId: "+fmt.Sprintf("%#v", this.MaxId)+",\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 *TLMsgUpdatePinnedMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&msg.TLMsgUpdatePinnedMessage{")
	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, "Silent: "+fmt.Sprintf("%#v", this.Silent)+",\n")
	s = append(s, "Unpin: "+fmt.Sprintf("%#v", this.Unpin)+",\n")
	s = append(s, "PmOneside: "+fmt.Sprintf("%#v", this.PmOneside)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\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 *TLMsgUnpinAllMessages) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&msg.TLMsgUnpinAllMessages{")
	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, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\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 valueToGoStringMsgTl(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

// RPCMsgClient is the client API for RPCMsg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RPCMsgClient interface {
	MsgSendMessage(ctx context.Context, in *TLMsgSendMessage, opts ...grpc.CallOption) (*mtproto.Updates, error)
	MsgSendMultiMessage(ctx context.Context, in *TLMsgSendMultiMessage, opts ...grpc.CallOption) (*mtproto.Updates, error)
	MsgPushUserMessage(ctx context.Context, in *TLMsgPushUserMessage, opts ...grpc.CallOption) (*mtproto.Bool, error)
	MsgReadMessageContents(ctx context.Context, in *TLMsgReadMessageContents, opts ...grpc.CallOption) (*mtproto.Messages_AffectedMessages, error)
	MsgSendMessageV2(ctx context.Context, in *TLMsgSendMessageV2, opts ...grpc.CallOption) (*mtproto.UpdateList, error)
	MsgEditMessage(ctx context.Context, in *TLMsgEditMessage, opts ...grpc.CallOption) (*mtproto.Updates, error)
	MsgDeleteMessages(ctx context.Context, in *TLMsgDeleteMessages, opts ...grpc.CallOption) (*mtproto.Messages_AffectedMessages, error)
	MsgDeleteHistory(ctx context.Context, in *TLMsgDeleteHistory, opts ...grpc.CallOption) (*mtproto.Messages_AffectedHistory, error)
	MsgDeletePhoneCallHistory(ctx context.Context, in *TLMsgDeletePhoneCallHistory, opts ...grpc.CallOption) (*mtproto.Messages_AffectedFoundMessages, error)
	MsgDeleteChatHistory(ctx context.Context, in *TLMsgDeleteChatHistory, opts ...grpc.CallOption) (*mtproto.Bool, error)
	MsgReadHistory(ctx context.Context, in *TLMsgReadHistory, opts ...grpc.CallOption) (*mtproto.Messages_AffectedMessages, error)
	MsgUpdatePinnedMessage(ctx context.Context, in *TLMsgUpdatePinnedMessage, opts ...grpc.CallOption) (*mtproto.Updates, error)
	MsgUnpinAllMessages(ctx context.Context, in *TLMsgUnpinAllMessages, opts ...grpc.CallOption) (*mtproto.Messages_AffectedHistory, error)
}

type rPCMsgClient struct {
	cc *grpc.ClientConn
}

func NewRPCMsgClient(cc *grpc.ClientConn) RPCMsgClient {
	return &rPCMsgClient{cc}
}

func (c *rPCMsgClient) MsgSendMessage(ctx context.Context, in *TLMsgSendMessage, opts ...grpc.CallOption) (*mtproto.Updates, error) {
	out := new(mtproto.Updates)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_sendMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgSendMultiMessage(ctx context.Context, in *TLMsgSendMultiMessage, opts ...grpc.CallOption) (*mtproto.Updates, error) {
	out := new(mtproto.Updates)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_sendMultiMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgPushUserMessage(ctx context.Context, in *TLMsgPushUserMessage, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_pushUserMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgReadMessageContents(ctx context.Context, in *TLMsgReadMessageContents, opts ...grpc.CallOption) (*mtproto.Messages_AffectedMessages, error) {
	out := new(mtproto.Messages_AffectedMessages)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_readMessageContents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgSendMessageV2(ctx context.Context, in *TLMsgSendMessageV2, opts ...grpc.CallOption) (*mtproto.UpdateList, error) {
	out := new(mtproto.UpdateList)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_sendMessageV2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgEditMessage(ctx context.Context, in *TLMsgEditMessage, opts ...grpc.CallOption) (*mtproto.Updates, error) {
	out := new(mtproto.Updates)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_editMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgDeleteMessages(ctx context.Context, in *TLMsgDeleteMessages, opts ...grpc.CallOption) (*mtproto.Messages_AffectedMessages, error) {
	out := new(mtproto.Messages_AffectedMessages)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_deleteMessages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgDeleteHistory(ctx context.Context, in *TLMsgDeleteHistory, opts ...grpc.CallOption) (*mtproto.Messages_AffectedHistory, error) {
	out := new(mtproto.Messages_AffectedHistory)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_deleteHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgDeletePhoneCallHistory(ctx context.Context, in *TLMsgDeletePhoneCallHistory, opts ...grpc.CallOption) (*mtproto.Messages_AffectedFoundMessages, error) {
	out := new(mtproto.Messages_AffectedFoundMessages)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_deletePhoneCallHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgDeleteChatHistory(ctx context.Context, in *TLMsgDeleteChatHistory, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_deleteChatHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgReadHistory(ctx context.Context, in *TLMsgReadHistory, opts ...grpc.CallOption) (*mtproto.Messages_AffectedMessages, error) {
	out := new(mtproto.Messages_AffectedMessages)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_readHistory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgUpdatePinnedMessage(ctx context.Context, in *TLMsgUpdatePinnedMessage, opts ...grpc.CallOption) (*mtproto.Updates, error) {
	out := new(mtproto.Updates)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_updatePinnedMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMsgClient) MsgUnpinAllMessages(ctx context.Context, in *TLMsgUnpinAllMessages, opts ...grpc.CallOption) (*mtproto.Messages_AffectedHistory, error) {
	out := new(mtproto.Messages_AffectedHistory)
	err := c.cc.Invoke(ctx, "/msg.RPCMsg/msg_unpinAllMessages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RPCMsgServer is the server API for RPCMsg service.
type RPCMsgServer interface {
	MsgSendMessage(context.Context, *TLMsgSendMessage) (*mtproto.Updates, error)
	MsgSendMultiMessage(context.Context, *TLMsgSendMultiMessage) (*mtproto.Updates, error)
	MsgPushUserMessage(context.Context, *TLMsgPushUserMessage) (*mtproto.Bool, error)
	MsgReadMessageContents(context.Context, *TLMsgReadMessageContents) (*mtproto.Messages_AffectedMessages, error)
	MsgSendMessageV2(context.Context, *TLMsgSendMessageV2) (*mtproto.UpdateList, error)
	MsgEditMessage(context.Context, *TLMsgEditMessage) (*mtproto.Updates, error)
	MsgDeleteMessages(context.Context, *TLMsgDeleteMessages) (*mtproto.Messages_AffectedMessages, error)
	MsgDeleteHistory(context.Context, *TLMsgDeleteHistory) (*mtproto.Messages_AffectedHistory, error)
	MsgDeletePhoneCallHistory(context.Context, *TLMsgDeletePhoneCallHistory) (*mtproto.Messages_AffectedFoundMessages, error)
	MsgDeleteChatHistory(context.Context, *TLMsgDeleteChatHistory) (*mtproto.Bool, error)
	MsgReadHistory(context.Context, *TLMsgReadHistory) (*mtproto.Messages_AffectedMessages, error)
	MsgUpdatePinnedMessage(context.Context, *TLMsgUpdatePinnedMessage) (*mtproto.Updates, error)
	MsgUnpinAllMessages(context.Context, *TLMsgUnpinAllMessages) (*mtproto.Messages_AffectedHistory, error)
}

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

func (*UnimplementedRPCMsgServer) MsgSendMessage(ctx context.Context, req *TLMsgSendMessage) (*mtproto.Updates, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgSendMessage not implemented")
}
func (*UnimplementedRPCMsgServer) MsgSendMultiMessage(ctx context.Context, req *TLMsgSendMultiMessage) (*mtproto.Updates, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgSendMultiMessage not implemented")
}
func (*UnimplementedRPCMsgServer) MsgPushUserMessage(ctx context.Context, req *TLMsgPushUserMessage) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgPushUserMessage not implemented")
}
func (*UnimplementedRPCMsgServer) MsgReadMessageContents(ctx context.Context, req *TLMsgReadMessageContents) (*mtproto.Messages_AffectedMessages, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgReadMessageContents not implemented")
}
func (*UnimplementedRPCMsgServer) MsgSendMessageV2(ctx context.Context, req *TLMsgSendMessageV2) (*mtproto.UpdateList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgSendMessageV2 not implemented")
}
func (*UnimplementedRPCMsgServer) MsgEditMessage(ctx context.Context, req *TLMsgEditMessage) (*mtproto.Updates, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgEditMessage not implemented")
}
func (*UnimplementedRPCMsgServer) MsgDeleteMessages(ctx context.Context, req *TLMsgDeleteMessages) (*mtproto.Messages_AffectedMessages, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgDeleteMessages not implemented")
}
func (*UnimplementedRPCMsgServer) MsgDeleteHistory(ctx context.Context, req *TLMsgDeleteHistory) (*mtproto.Messages_AffectedHistory, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgDeleteHistory not implemented")
}
func (*UnimplementedRPCMsgServer) MsgDeletePhoneCallHistory(ctx context.Context, req *TLMsgDeletePhoneCallHistory) (*mtproto.Messages_AffectedFoundMessages, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgDeletePhoneCallHistory not implemented")
}
func (*UnimplementedRPCMsgServer) MsgDeleteChatHistory(ctx context.Context, req *TLMsgDeleteChatHistory) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgDeleteChatHistory not implemented")
}
func (*UnimplementedRPCMsgServer) MsgReadHistory(ctx context.Context, req *TLMsgReadHistory) (*mtproto.Messages_AffectedMessages, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgReadHistory not implemented")
}
func (*UnimplementedRPCMsgServer) MsgUpdatePinnedMessage(ctx context.Context, req *TLMsgUpdatePinnedMessage) (*mtproto.Updates, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgUpdatePinnedMessage not implemented")
}
func (*UnimplementedRPCMsgServer) MsgUnpinAllMessages(ctx context.Context, req *TLMsgUnpinAllMessages) (*mtproto.Messages_AffectedHistory, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MsgUnpinAllMessages not implemented")
}

func RegisterRPCMsgServer(s *grpc.Server, srv RPCMsgServer) {
	s.RegisterService(&_RPCMsg_serviceDesc, srv)
}

func _RPCMsg_MsgSendMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgSendMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgSendMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgSendMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgSendMessage(ctx, req.(*TLMsgSendMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgSendMultiMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgSendMultiMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgSendMultiMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgSendMultiMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgSendMultiMessage(ctx, req.(*TLMsgSendMultiMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgPushUserMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgPushUserMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgPushUserMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgPushUserMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgPushUserMessage(ctx, req.(*TLMsgPushUserMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgReadMessageContents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgReadMessageContents)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgReadMessageContents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgReadMessageContents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgReadMessageContents(ctx, req.(*TLMsgReadMessageContents))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgSendMessageV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgSendMessageV2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgSendMessageV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgSendMessageV2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgSendMessageV2(ctx, req.(*TLMsgSendMessageV2))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgEditMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgEditMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgEditMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgEditMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgEditMessage(ctx, req.(*TLMsgEditMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgDeleteMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgDeleteMessages)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgDeleteMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgDeleteMessages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgDeleteMessages(ctx, req.(*TLMsgDeleteMessages))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgDeleteHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgDeleteHistory)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgDeleteHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgDeleteHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgDeleteHistory(ctx, req.(*TLMsgDeleteHistory))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgDeletePhoneCallHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgDeletePhoneCallHistory)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgDeletePhoneCallHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgDeletePhoneCallHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgDeletePhoneCallHistory(ctx, req.(*TLMsgDeletePhoneCallHistory))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgDeleteChatHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgDeleteChatHistory)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgDeleteChatHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgDeleteChatHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgDeleteChatHistory(ctx, req.(*TLMsgDeleteChatHistory))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgReadHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgReadHistory)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgReadHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgReadHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgReadHistory(ctx, req.(*TLMsgReadHistory))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgUpdatePinnedMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgUpdatePinnedMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgUpdatePinnedMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgUpdatePinnedMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgUpdatePinnedMessage(ctx, req.(*TLMsgUpdatePinnedMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMsg_MsgUnpinAllMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMsgUnpinAllMessages)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMsgServer).MsgUnpinAllMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/msg.RPCMsg/MsgUnpinAllMessages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMsgServer).MsgUnpinAllMessages(ctx, req.(*TLMsgUnpinAllMessages))
	}
	return interceptor(ctx, in, info, handler)
}

var _RPCMsg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "msg.RPCMsg",
	HandlerType: (*RPCMsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "msg_sendMessage",
			Handler:    _RPCMsg_MsgSendMessage_Handler,
		},
		{
			MethodName: "msg_sendMultiMessage",
			Handler:    _RPCMsg_MsgSendMultiMessage_Handler,
		},
		{
			MethodName: "msg_pushUserMessage",
			Handler:    _RPCMsg_MsgPushUserMessage_Handler,
		},
		{
			MethodName: "msg_readMessageContents",
			Handler:    _RPCMsg_MsgReadMessageContents_Handler,
		},
		{
			MethodName: "msg_sendMessageV2",
			Handler:    _RPCMsg_MsgSendMessageV2_Handler,
		},
		{
			MethodName: "msg_editMessage",
			Handler:    _RPCMsg_MsgEditMessage_Handler,
		},
		{
			MethodName: "msg_deleteMessages",
			Handler:    _RPCMsg_MsgDeleteMessages_Handler,
		},
		{
			MethodName: "msg_deleteHistory",
			Handler:    _RPCMsg_MsgDeleteHistory_Handler,
		},
		{
			MethodName: "msg_deletePhoneCallHistory",
			Handler:    _RPCMsg_MsgDeletePhoneCallHistory_Handler,
		},
		{
			MethodName: "msg_deleteChatHistory",
			Handler:    _RPCMsg_MsgDeleteChatHistory_Handler,
		},
		{
			MethodName: "msg_readHistory",
			Handler:    _RPCMsg_MsgReadHistory_Handler,
		},
		{
			MethodName: "msg_updatePinnedMessage",
			Handler:    _RPCMsg_MsgUpdatePinnedMessage_Handler,
		},
		{
			MethodName: "msg_unpinAllMessages",
			Handler:    _RPCMsg_MsgUnpinAllMessages_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "msg.tl.proto",
}

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

func (m *ContentMessage) 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.Reaction {
		i--
		if m.Reaction {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.MediaUnread {
		i--
		if m.MediaUnread {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Mentioned {
		i--
		if m.Mentioned {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.DialogMessageId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.DialogMessageId))
		i--
		dAtA[i] = 0x20
	}
	if m.Id != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PredicateName) > 0 {
		i -= len(m.PredicateName)
		copy(dAtA[i:], m.PredicateName)
		i = encodeVarintMsgTl(dAtA, i, uint64(len(m.PredicateName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLContentMessage) 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.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *OutboxMessage) 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.ScheduleDate != nil {
		{
			size, err := m.ScheduleDate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.RandomId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.RandomId))
		i--
		dAtA[i] = 0x28
	}
	if m.Background {
		i--
		if m.Background {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.NoWebpage {
		i--
		if m.NoWebpage {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PredicateName) > 0 {
		i -= len(m.PredicateName)
		copy(dAtA[i:], m.PredicateName)
		i = encodeVarintMsgTl(dAtA, i, uint64(len(m.PredicateName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLOutboxMessage) 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.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Sender) 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.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x28
	}
	if m.Type != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PredicateName) > 0 {
		i -= len(m.PredicateName)
		copy(dAtA[i:], m.PredicateName)
		i = encodeVarintMsgTl(dAtA, i, uint64(len(m.PredicateName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLSender) 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.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgSendMessage) 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.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgSendMultiMessage) 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.Message) > 0 {
		for iNdEx := len(m.Message) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Message[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMsgTl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgPushUserMessage) 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.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.PushType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PushType))
		i--
		dAtA[i] = 0x38
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgReadMessageContents) 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.Id) > 0 {
		for iNdEx := len(m.Id) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Id[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMsgTl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgSendMessageV2) 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.Message) > 0 {
		for iNdEx := len(m.Message) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Message[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMsgTl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgEditMessage) 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.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.EditType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.EditType))
		i--
		dAtA[i] = 0x38
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgDeleteMessages) 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.Id) > 0 {
		dAtA10 := make([]byte, len(m.Id)*10)
		var j9 int
		for _, num1 := range m.Id {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		i -= j9
		copy(dAtA[i:], dAtA10[:j9])
		i = encodeVarintMsgTl(dAtA, i, uint64(j9))
		i--
		dAtA[i] = 0x42
	}
	if m.Revoke {
		i--
		if m.Revoke {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgDeleteHistory) 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.MaxId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.MaxId))
		i--
		dAtA[i] = 0x48
	}
	if m.Revoke {
		i--
		if m.Revoke {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.JustClear {
		i--
		if m.JustClear {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgDeletePhoneCallHistory) 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.Revoke {
		i--
		if m.Revoke {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgDeleteChatHistory) 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.DeleteUserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.DeleteUserId))
		i--
		dAtA[i] = 0x20
	}
	if m.ChatId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.ChatId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgReadHistory) 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.MaxId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.MaxId))
		i--
		dAtA[i] = 0x38
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgUpdatePinnedMessage) 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.Id != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x50
	}
	if m.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x48
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x40
	}
	if m.PmOneside {
		i--
		if m.PmOneside {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Unpin {
		i--
		if m.Unpin {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Silent {
		i--
		if m.Silent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMsgUnpinAllMessages) 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.PeerId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerType != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x28
	}
	if m.AuthKeyId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.AuthKeyId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMsgTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintMsgTl(dAtA []byte, offset int, v uint64) int {
	offset -= sovMsgTl(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ContentMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PredicateName)
	if l > 0 {
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.Id != 0 {
		n += 1 + sovMsgTl(uint64(m.Id))
	}
	if m.DialogMessageId != 0 {
		n += 1 + sovMsgTl(uint64(m.DialogMessageId))
	}
	if m.Mentioned {
		n += 2
	}
	if m.MediaUnread {
		n += 2
	}
	if m.Reaction {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLContentMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data2 != nil {
		l = m.Data2.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutboxMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PredicateName)
	if l > 0 {
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.NoWebpage {
		n += 2
	}
	if m.Background {
		n += 2
	}
	if m.RandomId != 0 {
		n += 1 + sovMsgTl(uint64(m.RandomId))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.ScheduleDate != nil {
		l = m.ScheduleDate.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLOutboxMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data2 != nil {
		l = m.Data2.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Sender) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PredicateName)
	if l > 0 {
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.Type != 0 {
		n += 1 + sovMsgTl(uint64(m.Type))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLSender) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data2 != nil {
		l = m.Data2.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgSendMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgSendMultiMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if len(m.Message) > 0 {
		for _, e := range m.Message {
			l = e.Size()
			n += 1 + l + sovMsgTl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgPushUserMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.PushType != 0 {
		n += 1 + sovMsgTl(uint64(m.PushType))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgReadMessageContents) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if len(m.Id) > 0 {
		for _, e := range m.Id {
			l = e.Size()
			n += 1 + l + sovMsgTl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgSendMessageV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if len(m.Message) > 0 {
		for _, e := range m.Message {
			l = e.Size()
			n += 1 + l + sovMsgTl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgEditMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.EditType != 0 {
		n += 1 + sovMsgTl(uint64(m.EditType))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovMsgTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgDeleteMessages) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.Revoke {
		n += 2
	}
	if len(m.Id) > 0 {
		l = 0
		for _, e := range m.Id {
			l += sovMsgTl(uint64(e))
		}
		n += 1 + sovMsgTl(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgDeleteHistory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.JustClear {
		n += 2
	}
	if m.Revoke {
		n += 2
	}
	if m.MaxId != 0 {
		n += 1 + sovMsgTl(uint64(m.MaxId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *TLMsgDeleteChatHistory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.ChatId != 0 {
		n += 1 + sovMsgTl(uint64(m.ChatId))
	}
	if m.DeleteUserId != 0 {
		n += 1 + sovMsgTl(uint64(m.DeleteUserId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgReadHistory) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.MaxId != 0 {
		n += 1 + sovMsgTl(uint64(m.MaxId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMsgUpdatePinnedMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMsgTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMsgTl(uint64(m.UserId))
	}
	if m.AuthKeyId != 0 {
		n += 1 + sovMsgTl(uint64(m.AuthKeyId))
	}
	if m.Silent {
		n += 2
	}
	if m.Unpin {
		n += 2
	}
	if m.PmOneside {
		n += 2
	}
	if m.PeerType != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMsgTl(uint64(m.PeerId))
	}
	if m.Id != 0 {
		n += 1 + sovMsgTl(uint64(m.Id))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovMsgTl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMsgTl(x uint64) (n int) {
	return sovMsgTl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ContentMessage) 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 ErrIntOverflowMsgTl
			}
			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: ContentMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContentMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PredicateName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				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 ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PredicateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowMsgTl
				}
				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 Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DialogMessageId", wireType)
			}
			m.DialogMessageId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DialogMessageId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mentioned", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Mentioned = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MediaUnread", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.MediaUnread = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reaction", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Reaction = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLContentMessage) 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 ErrIntOverflowMsgTl
			}
			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_contentMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_contentMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &ContentMessage{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *OutboxMessage) 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 ErrIntOverflowMsgTl
			}
			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: OutboxMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutboxMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PredicateName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				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 ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PredicateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowMsgTl
				}
				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 NoWebpage", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NoWebpage = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Background", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Background = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RandomId", wireType)
			}
			m.RandomId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RandomId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &mtproto.Message{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScheduleDate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScheduleDate == nil {
				m.ScheduleDate = &types.Int32Value{}
			}
			if err := m.ScheduleDate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLOutboxMessage) 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 ErrIntOverflowMsgTl
			}
			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_outboxMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_outboxMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &OutboxMessage{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *Sender) 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 ErrIntOverflowMsgTl
			}
			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: Sender: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sender: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PredicateName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				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 ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PredicateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLSender) 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 ErrIntOverflowMsgTl
			}
			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_sender: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_sender: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &Sender{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgSendMessage) 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 ErrIntOverflowMsgTl
			}
			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_msg_sendMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_sendMessage: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &OutboxMessage{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgSendMultiMessage) 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 ErrIntOverflowMsgTl
			}
			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_msg_sendMultiMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_sendMultiMessage: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = append(m.Message, &OutboxMessage{})
			if err := m.Message[len(m.Message)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgPushUserMessage) 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 ErrIntOverflowMsgTl
			}
			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_msg_pushUserMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_pushUserMessage: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PushType", wireType)
			}
			m.PushType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PushType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &OutboxMessage{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgReadMessageContents) 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 ErrIntOverflowMsgTl
			}
			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_msg_readMessageContents: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_readMessageContents: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = append(m.Id, &ContentMessage{})
			if err := m.Id[len(m.Id)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgSendMessageV2) 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 ErrIntOverflowMsgTl
			}
			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_msg_sendMessageV2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_sendMessageV2: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = append(m.Message, &OutboxMessage{})
			if err := m.Message[len(m.Message)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgEditMessage) 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 ErrIntOverflowMsgTl
			}
			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_msg_editMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_editMessage: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EditType", wireType)
			}
			m.EditType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EditType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &OutboxMessage{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgDeleteMessages) 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 ErrIntOverflowMsgTl
			}
			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_msg_deleteMessages: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_deleteMessages: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revoke", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Revoke = bool(v != 0)
		case 8:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMsgTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Id = append(m.Id, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMsgTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMsgTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMsgTl
				}
				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.Id) == 0 {
					m.Id = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMsgTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Id = append(m.Id, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgDeleteHistory) 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 ErrIntOverflowMsgTl
			}
			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_msg_deleteHistory: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_deleteHistory: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JustClear", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.JustClear = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revoke", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Revoke = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxId", wireType)
			}
			m.MaxId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgDeletePhoneCallHistory) 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 ErrIntOverflowMsgTl
			}
			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_msg_deletePhoneCallHistory: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_deletePhoneCallHistory: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revoke", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Revoke = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgDeleteChatHistory) 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 ErrIntOverflowMsgTl
			}
			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_msg_deleteChatHistory: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_deleteChatHistory: 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 ErrIntOverflowMsgTl
				}
				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 ChatId", wireType)
			}
			m.ChatId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChatId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeleteUserId", wireType)
			}
			m.DeleteUserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeleteUserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgReadHistory) 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 ErrIntOverflowMsgTl
			}
			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_msg_readHistory: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_readHistory: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxId", wireType)
			}
			m.MaxId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgUpdatePinnedMessage) 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 ErrIntOverflowMsgTl
			}
			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_msg_updatePinnedMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_updatePinnedMessage: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Silent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Silent = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unpin", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Unpin = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PmOneside", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PmOneside = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 *TLMsgUnpinAllMessages) 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 ErrIntOverflowMsgTl
			}
			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_msg_unpinAllMessages: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_msg_unpinAllMessages: 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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				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 ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthKeyId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
			}
			m.PeerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMsgTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgTl
			}
			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 skipMsgTl(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, ErrIntOverflowMsgTl
			}
			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, ErrIntOverflowMsgTl
				}
				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, ErrIntOverflowMsgTl
				}
				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, ErrInvalidLengthMsgTl
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMsgTl
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMsgTl
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMsgTl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMsgTl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMsgTl = fmt.Errorf("proto: unexpected end of group")
)