message.tl.pb.go

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

package message

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "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_message_getUserMessage                       TLConstructor = 2060235208
	CRC32_message_getUserMessageList                   TLConstructor = -749200346
	CRC32_message_getUserMessageListByDataIdList       TLConstructor = 290824571
	CRC32_message_getUserMessageListByDataIdUserIdList TLConstructor = 749890097
	CRC32_message_getHistoryMessages                   TLConstructor = 50897728
	CRC32_message_getHistoryMessagesCount              TLConstructor = 256933395
	CRC32_message_getPeerUserMessageId                 TLConstructor = 1940829983
	CRC32_message_getPeerUserMessage                   TLConstructor = 1662161426
	CRC32_message_searchByMediaType                    TLConstructor = -1152381832
	CRC32_message_search                               TLConstructor = 251910661
	CRC32_message_searchGlobal                         TLConstructor = 1113214626
	CRC32_message_searchByPinned                       TLConstructor = 721580084
	CRC32_message_getSearchCounter                     TLConstructor = -489963706
	CRC32_message_searchV2                             TLConstructor = -356633351
	CRC32_message_getLastTwoPinnedMessageId            TLConstructor = -1348859861
	CRC32_message_updatePinnedMessageId                TLConstructor = -182391344
	CRC32_message_getPinnedMessageIdList               TLConstructor = -637415203
	CRC32_message_unPinAllMessages                     TLConstructor = -368432525
	CRC32_message_getUnreadMentions                    TLConstructor = 1877050548
	CRC32_message_getUnreadMentionsCount               TLConstructor = -1254023095
)

var TLConstructor_name = map[int32]string{
	0:           "CRC32_UNKNOWN",
	2060235208:  "CRC32_message_getUserMessage",
	-749200346:  "CRC32_message_getUserMessageList",
	290824571:   "CRC32_message_getUserMessageListByDataIdList",
	749890097:   "CRC32_message_getUserMessageListByDataIdUserIdList",
	50897728:    "CRC32_message_getHistoryMessages",
	256933395:   "CRC32_message_getHistoryMessagesCount",
	1940829983:  "CRC32_message_getPeerUserMessageId",
	1662161426:  "CRC32_message_getPeerUserMessage",
	-1152381832: "CRC32_message_searchByMediaType",
	251910661:   "CRC32_message_search",
	1113214626:  "CRC32_message_searchGlobal",
	721580084:   "CRC32_message_searchByPinned",
	-489963706:  "CRC32_message_getSearchCounter",
	-356633351:  "CRC32_message_searchV2",
	-1348859861: "CRC32_message_getLastTwoPinnedMessageId",
	-182391344:  "CRC32_message_updatePinnedMessageId",
	-637415203:  "CRC32_message_getPinnedMessageIdList",
	-368432525:  "CRC32_message_unPinAllMessages",
	1877050548:  "CRC32_message_getUnreadMentions",
	-1254023095: "CRC32_message_getUnreadMentionsCount",
}

var TLConstructor_value = map[string]int32{
	"CRC32_UNKNOWN":                                      0,
	"CRC32_message_getUserMessage":                       2060235208,
	"CRC32_message_getUserMessageList":                   -749200346,
	"CRC32_message_getUserMessageListByDataIdList":       290824571,
	"CRC32_message_getUserMessageListByDataIdUserIdList": 749890097,
	"CRC32_message_getHistoryMessages":                   50897728,
	"CRC32_message_getHistoryMessagesCount":              256933395,
	"CRC32_message_getPeerUserMessageId":                 1940829983,
	"CRC32_message_getPeerUserMessage":                   1662161426,
	"CRC32_message_searchByMediaType":                    -1152381832,
	"CRC32_message_search":                               251910661,
	"CRC32_message_searchGlobal":                         1113214626,
	"CRC32_message_searchByPinned":                       721580084,
	"CRC32_message_getSearchCounter":                     -489963706,
	"CRC32_message_searchV2":                             -356633351,
	"CRC32_message_getLastTwoPinnedMessageId":            -1348859861,
	"CRC32_message_updatePinnedMessageId":                -182391344,
	"CRC32_message_getPinnedMessageIdList":               -637415203,
	"CRC32_message_unPinAllMessages":                     -368432525,
	"CRC32_message_getUnreadMentions":                    1877050548,
	"CRC32_message_getUnreadMentionsCount":               -1254023095,
}

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

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

//--------------------------------------------------------------------------------------------
type TLMessageGetUserMessage struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Id                   int32         `protobuf:"varint,4,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetUserMessage proto.InternalMessageInfo

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

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

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

//--------------------------------------------------------------------------------------------
type TLMessageGetUserMessageList struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	IdList               []int32       `protobuf:"varint,4,rep,packed,name=id_list,json=idList,proto3" json:"id_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetUserMessageList proto.InternalMessageInfo

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

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

func (m *TLMessageGetUserMessageList) GetIdList() []int32 {
	if m != nil {
		return m.IdList
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMessageGetUserMessageListByDataIdList struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	IdList               []int64       `protobuf:"varint,4,rep,packed,name=id_list,json=idList,proto3" json:"id_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetUserMessageListByDataIdList proto.InternalMessageInfo

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

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

func (m *TLMessageGetUserMessageListByDataIdList) GetIdList() []int64 {
	if m != nil {
		return m.IdList
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMessageGetUserMessageListByDataIdUserIdList struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	Id                   int64         `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"`
	UserIdList           []int64       `protobuf:"varint,4,rep,packed,name=user_id_list,json=userIdList,proto3" json:"user_id_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetUserMessageListByDataIdUserIdList proto.InternalMessageInfo

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

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

func (m *TLMessageGetUserMessageListByDataIdUserIdList) GetUserIdList() []int64 {
	if m != nil {
		return m.UserIdList
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMessageGetHistoryMessages struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	OffsetId             int32         `protobuf:"varint,6,opt,name=offset_id,json=offsetId,proto3" json:"offset_id,omitempty"`
	OffsetDate           int32         `protobuf:"varint,7,opt,name=offset_date,json=offsetDate,proto3" json:"offset_date,omitempty"`
	AddOffset            int32         `protobuf:"varint,8,opt,name=add_offset,json=addOffset,proto3" json:"add_offset,omitempty"`
	Limit                int32         `protobuf:"varint,9,opt,name=limit,proto3" json:"limit,omitempty"`
	MaxId                int32         `protobuf:"varint,10,opt,name=max_id,json=maxId,proto3" json:"max_id,omitempty"`
	MinId                int32         `protobuf:"varint,11,opt,name=min_id,json=minId,proto3" json:"min_id,omitempty"`
	Hash                 int64         `protobuf:"varint,12,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetHistoryMessages proto.InternalMessageInfo

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

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

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

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

func (m *TLMessageGetHistoryMessages) GetOffsetId() int32 {
	if m != nil {
		return m.OffsetId
	}
	return 0
}

func (m *TLMessageGetHistoryMessages) GetOffsetDate() int32 {
	if m != nil {
		return m.OffsetDate
	}
	return 0
}

func (m *TLMessageGetHistoryMessages) GetAddOffset() int32 {
	if m != nil {
		return m.AddOffset
	}
	return 0
}

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

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

func (m *TLMessageGetHistoryMessages) GetMinId() int32 {
	if m != nil {
		return m.MinId
	}
	return 0
}

func (m *TLMessageGetHistoryMessages) GetHash() int64 {
	if m != nil {
		return m.Hash
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMessageGetHistoryMessagesCount struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,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 *TLMessageGetHistoryMessagesCount) Reset()         { *m = TLMessageGetHistoryMessagesCount{} }
func (m *TLMessageGetHistoryMessagesCount) String() string { return proto.CompactTextString(m) }
func (*TLMessageGetHistoryMessagesCount) ProtoMessage()    {}
func (*TLMessageGetHistoryMessagesCount) Descriptor() ([]byte, []int) {
	return fileDescriptor_854009303dbd8a76, []int{5}
}
func (m *TLMessageGetHistoryMessagesCount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLMessageGetHistoryMessagesCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLMessageGetHistoryMessagesCount.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 *TLMessageGetHistoryMessagesCount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLMessageGetHistoryMessagesCount.Merge(m, src)
}
func (m *TLMessageGetHistoryMessagesCount) XXX_Size() int {
	return m.Size()
}
func (m *TLMessageGetHistoryMessagesCount) XXX_DiscardUnknown() {
	xxx_messageInfo_TLMessageGetHistoryMessagesCount.DiscardUnknown(m)
}

var xxx_messageInfo_TLMessageGetHistoryMessagesCount proto.InternalMessageInfo

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

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

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

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

//--------------------------------------------------------------------------------------------
type TLMessageGetPeerUserMessageId struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerUserId           int64         `protobuf:"varint,4,opt,name=peer_user_id,json=peerUserId,proto3" json:"peer_user_id,omitempty"`
	MsgId                int32         `protobuf:"varint,5,opt,name=msg_id,json=msgId,proto3" json:"msg_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetPeerUserMessageId proto.InternalMessageInfo

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

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

func (m *TLMessageGetPeerUserMessageId) GetPeerUserId() int64 {
	if m != nil {
		return m.PeerUserId
	}
	return 0
}

func (m *TLMessageGetPeerUserMessageId) GetMsgId() int32 {
	if m != nil {
		return m.MsgId
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMessageGetPeerUserMessage struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerUserId           int64         `protobuf:"varint,4,opt,name=peer_user_id,json=peerUserId,proto3" json:"peer_user_id,omitempty"`
	MsgId                int32         `protobuf:"varint,5,opt,name=msg_id,json=msgId,proto3" json:"msg_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetPeerUserMessage proto.InternalMessageInfo

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

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

func (m *TLMessageGetPeerUserMessage) GetPeerUserId() int64 {
	if m != nil {
		return m.PeerUserId
	}
	return 0
}

func (m *TLMessageGetPeerUserMessage) GetMsgId() int32 {
	if m != nil {
		return m.MsgId
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMessageSearchByMediaType struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	MediaType            int32         `protobuf:"varint,6,opt,name=media_type,json=mediaType,proto3" json:"media_type,omitempty"`
	Offset               int32         `protobuf:"varint,7,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit                int32         `protobuf:"varint,8,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageSearchByMediaType proto.InternalMessageInfo

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

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

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

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

func (m *TLMessageSearchByMediaType) GetMediaType() int32 {
	if m != nil {
		return m.MediaType
	}
	return 0
}

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

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

//--------------------------------------------------------------------------------------------
type TLMessageSearch struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Q                    string        `protobuf:"bytes,6,opt,name=q,proto3" json:"q,omitempty"`
	Offset               int32         `protobuf:"varint,7,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit                int32         `protobuf:"varint,8,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageSearch proto.InternalMessageInfo

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

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

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

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

func (m *TLMessageSearch) GetQ() string {
	if m != nil {
		return m.Q
	}
	return ""
}

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

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

//--------------------------------------------------------------------------------------------
type TLMessageSearchGlobal struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Q                    string        `protobuf:"bytes,4,opt,name=q,proto3" json:"q,omitempty"`
	Offset               int32         `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit                int32         `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageSearchGlobal proto.InternalMessageInfo

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

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

func (m *TLMessageSearchGlobal) GetQ() string {
	if m != nil {
		return m.Q
	}
	return ""
}

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

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

//--------------------------------------------------------------------------------------------
type TLMessageSearchByPinned struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,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 *TLMessageSearchByPinned) Reset()         { *m = TLMessageSearchByPinned{} }
func (m *TLMessageSearchByPinned) String() string { return proto.CompactTextString(m) }
func (*TLMessageSearchByPinned) ProtoMessage()    {}
func (*TLMessageSearchByPinned) Descriptor() ([]byte, []int) {
	return fileDescriptor_854009303dbd8a76, []int{11}
}
func (m *TLMessageSearchByPinned) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLMessageSearchByPinned) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLMessageSearchByPinned.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 *TLMessageSearchByPinned) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLMessageSearchByPinned.Merge(m, src)
}
func (m *TLMessageSearchByPinned) XXX_Size() int {
	return m.Size()
}
func (m *TLMessageSearchByPinned) XXX_DiscardUnknown() {
	xxx_messageInfo_TLMessageSearchByPinned.DiscardUnknown(m)
}

var xxx_messageInfo_TLMessageSearchByPinned proto.InternalMessageInfo

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

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

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

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

//--------------------------------------------------------------------------------------------
type TLMessageGetSearchCounter struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	MediaType            int32         `protobuf:"varint,6,opt,name=media_type,json=mediaType,proto3" json:"media_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetSearchCounter proto.InternalMessageInfo

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

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

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

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

func (m *TLMessageGetSearchCounter) GetMediaType() int32 {
	if m != nil {
		return m.MediaType
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMessageSearchV2 struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Q                    string        `protobuf:"bytes,6,opt,name=q,proto3" json:"q,omitempty"`
	FromId               int64         `protobuf:"varint,7,opt,name=from_id,json=fromId,proto3" json:"from_id,omitempty"`
	MinDate              int32         `protobuf:"varint,8,opt,name=min_date,json=minDate,proto3" json:"min_date,omitempty"`
	MaxDate              int32         `protobuf:"varint,9,opt,name=max_date,json=maxDate,proto3" json:"max_date,omitempty"`
	OffsetId             int32         `protobuf:"varint,10,opt,name=offset_id,json=offsetId,proto3" json:"offset_id,omitempty"`
	AddOffset            int32         `protobuf:"varint,11,opt,name=add_offset,json=addOffset,proto3" json:"add_offset,omitempty"`
	Limit                int32         `protobuf:"varint,12,opt,name=limit,proto3" json:"limit,omitempty"`
	MaxId                int32         `protobuf:"varint,13,opt,name=max_id,json=maxId,proto3" json:"max_id,omitempty"`
	MinId                int32         `protobuf:"varint,14,opt,name=min_id,json=minId,proto3" json:"min_id,omitempty"`
	Hash                 int64         `protobuf:"varint,15,opt,name=hash,proto3" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageSearchV2 proto.InternalMessageInfo

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

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

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

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

func (m *TLMessageSearchV2) GetQ() string {
	if m != nil {
		return m.Q
	}
	return ""
}

func (m *TLMessageSearchV2) GetFromId() int64 {
	if m != nil {
		return m.FromId
	}
	return 0
}

func (m *TLMessageSearchV2) GetMinDate() int32 {
	if m != nil {
		return m.MinDate
	}
	return 0
}

func (m *TLMessageSearchV2) GetMaxDate() int32 {
	if m != nil {
		return m.MaxDate
	}
	return 0
}

func (m *TLMessageSearchV2) GetOffsetId() int32 {
	if m != nil {
		return m.OffsetId
	}
	return 0
}

func (m *TLMessageSearchV2) GetAddOffset() int32 {
	if m != nil {
		return m.AddOffset
	}
	return 0
}

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

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

func (m *TLMessageSearchV2) GetMinId() int32 {
	if m != nil {
		return m.MinId
	}
	return 0
}

func (m *TLMessageSearchV2) GetHash() int64 {
	if m != nil {
		return m.Hash
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMessageGetLastTwoPinnedMessageId struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,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 *TLMessageGetLastTwoPinnedMessageId) Reset()         { *m = TLMessageGetLastTwoPinnedMessageId{} }
func (m *TLMessageGetLastTwoPinnedMessageId) String() string { return proto.CompactTextString(m) }
func (*TLMessageGetLastTwoPinnedMessageId) ProtoMessage()    {}
func (*TLMessageGetLastTwoPinnedMessageId) Descriptor() ([]byte, []int) {
	return fileDescriptor_854009303dbd8a76, []int{14}
}
func (m *TLMessageGetLastTwoPinnedMessageId) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLMessageGetLastTwoPinnedMessageId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLMessageGetLastTwoPinnedMessageId.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 *TLMessageGetLastTwoPinnedMessageId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLMessageGetLastTwoPinnedMessageId.Merge(m, src)
}
func (m *TLMessageGetLastTwoPinnedMessageId) XXX_Size() int {
	return m.Size()
}
func (m *TLMessageGetLastTwoPinnedMessageId) XXX_DiscardUnknown() {
	xxx_messageInfo_TLMessageGetLastTwoPinnedMessageId.DiscardUnknown(m)
}

var xxx_messageInfo_TLMessageGetLastTwoPinnedMessageId proto.InternalMessageInfo

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

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

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

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

//--------------------------------------------------------------------------------------------
type TLMessageUpdatePinnedMessageId struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Id                   int32         `protobuf:"varint,6,opt,name=id,proto3" json:"id,omitempty"`
	Pinned               *mtproto.Bool `protobuf:"bytes,7,opt,name=pinned,proto3" json:"pinned,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageUpdatePinnedMessageId proto.InternalMessageInfo

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

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

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

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

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

func (m *TLMessageUpdatePinnedMessageId) GetPinned() *mtproto.Bool {
	if m != nil {
		return m.Pinned
	}
	return nil
}

//--------------------------------------------------------------------------------------------
type TLMessageGetPinnedMessageIdList struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,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 *TLMessageGetPinnedMessageIdList) Reset()         { *m = TLMessageGetPinnedMessageIdList{} }
func (m *TLMessageGetPinnedMessageIdList) String() string { return proto.CompactTextString(m) }
func (*TLMessageGetPinnedMessageIdList) ProtoMessage()    {}
func (*TLMessageGetPinnedMessageIdList) Descriptor() ([]byte, []int) {
	return fileDescriptor_854009303dbd8a76, []int{16}
}
func (m *TLMessageGetPinnedMessageIdList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLMessageGetPinnedMessageIdList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLMessageGetPinnedMessageIdList.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 *TLMessageGetPinnedMessageIdList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLMessageGetPinnedMessageIdList.Merge(m, src)
}
func (m *TLMessageGetPinnedMessageIdList) XXX_Size() int {
	return m.Size()
}
func (m *TLMessageGetPinnedMessageIdList) XXX_DiscardUnknown() {
	xxx_messageInfo_TLMessageGetPinnedMessageIdList.DiscardUnknown(m)
}

var xxx_messageInfo_TLMessageGetPinnedMessageIdList proto.InternalMessageInfo

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

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

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

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

//--------------------------------------------------------------------------------------------
type TLMessageUnPinAllMessages struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,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 *TLMessageUnPinAllMessages) Reset()         { *m = TLMessageUnPinAllMessages{} }
func (m *TLMessageUnPinAllMessages) String() string { return proto.CompactTextString(m) }
func (*TLMessageUnPinAllMessages) ProtoMessage()    {}
func (*TLMessageUnPinAllMessages) Descriptor() ([]byte, []int) {
	return fileDescriptor_854009303dbd8a76, []int{17}
}
func (m *TLMessageUnPinAllMessages) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLMessageUnPinAllMessages) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLMessageUnPinAllMessages.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 *TLMessageUnPinAllMessages) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLMessageUnPinAllMessages.Merge(m, src)
}
func (m *TLMessageUnPinAllMessages) XXX_Size() int {
	return m.Size()
}
func (m *TLMessageUnPinAllMessages) XXX_DiscardUnknown() {
	xxx_messageInfo_TLMessageUnPinAllMessages.DiscardUnknown(m)
}

var xxx_messageInfo_TLMessageUnPinAllMessages proto.InternalMessageInfo

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

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

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

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

//--------------------------------------------------------------------------------------------
type TLMessageGetUnreadMentions struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	OffsetId             int32         `protobuf:"varint,6,opt,name=offset_id,json=offsetId,proto3" json:"offset_id,omitempty"`
	AddOffset            int32         `protobuf:"varint,7,opt,name=add_offset,json=addOffset,proto3" json:"add_offset,omitempty"`
	Limit                int32         `protobuf:"varint,8,opt,name=limit,proto3" json:"limit,omitempty"`
	MinId                int32         `protobuf:"varint,9,opt,name=min_id,json=minId,proto3" json:"min_id,omitempty"`
	MaxInt               int32         `protobuf:"varint,10,opt,name=max_int,json=maxInt,proto3" json:"max_int,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLMessageGetUnreadMentions proto.InternalMessageInfo

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

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

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

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

func (m *TLMessageGetUnreadMentions) GetOffsetId() int32 {
	if m != nil {
		return m.OffsetId
	}
	return 0
}

func (m *TLMessageGetUnreadMentions) GetAddOffset() int32 {
	if m != nil {
		return m.AddOffset
	}
	return 0
}

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

func (m *TLMessageGetUnreadMentions) GetMinId() int32 {
	if m != nil {
		return m.MinId
	}
	return 0
}

func (m *TLMessageGetUnreadMentions) GetMaxInt() int32 {
	if m != nil {
		return m.MaxInt
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLMessageGetUnreadMentionsCount struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=message.TLConstructor" json:"constructor,omitempty"`
	UserId               int64         `protobuf:"varint,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	PeerType             int32         `protobuf:"varint,4,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,5,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 *TLMessageGetUnreadMentionsCount) Reset()         { *m = TLMessageGetUnreadMentionsCount{} }
func (m *TLMessageGetUnreadMentionsCount) String() string { return proto.CompactTextString(m) }
func (*TLMessageGetUnreadMentionsCount) ProtoMessage()    {}
func (*TLMessageGetUnreadMentionsCount) Descriptor() ([]byte, []int) {
	return fileDescriptor_854009303dbd8a76, []int{19}
}
func (m *TLMessageGetUnreadMentionsCount) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLMessageGetUnreadMentionsCount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLMessageGetUnreadMentionsCount.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 *TLMessageGetUnreadMentionsCount) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLMessageGetUnreadMentionsCount.Merge(m, src)
}
func (m *TLMessageGetUnreadMentionsCount) XXX_Size() int {
	return m.Size()
}
func (m *TLMessageGetUnreadMentionsCount) XXX_DiscardUnknown() {
	xxx_messageInfo_TLMessageGetUnreadMentionsCount.DiscardUnknown(m)
}

var xxx_messageInfo_TLMessageGetUnreadMentionsCount proto.InternalMessageInfo

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

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

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

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

//--------------------------------------------------------------------------------------------
// Vector api result type
type Vector_MessageBox struct {
	Datas                []*mtproto.MessageBox `protobuf:"bytes,1,rep,name=datas,proto3" json:"datas,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_Vector_MessageBox proto.InternalMessageInfo

func (m *Vector_MessageBox) GetDatas() []*mtproto.MessageBox {
	if m != nil {
		return m.Datas
	}
	return nil
}

type Vector_Int struct {
	Datas                []int32  `protobuf:"varint,1,rep,packed,name=datas,proto3" json:"datas,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Vector_Int proto.InternalMessageInfo

func (m *Vector_Int) GetDatas() []int32 {
	if m != nil {
		return m.Datas
	}
	return nil
}

func init() {
	proto.RegisterEnum("message.TLConstructor", TLConstructor_name, TLConstructor_value)
	proto.RegisterType((*TLMessageGetUserMessage)(nil), "message.TL_message_getUserMessage")
	proto.RegisterType((*TLMessageGetUserMessageList)(nil), "message.TL_message_getUserMessageList")
	proto.RegisterType((*TLMessageGetUserMessageListByDataIdList)(nil), "message.TL_message_getUserMessageListByDataIdList")
	proto.RegisterType((*TLMessageGetUserMessageListByDataIdUserIdList)(nil), "message.TL_message_getUserMessageListByDataIdUserIdList")
	proto.RegisterType((*TLMessageGetHistoryMessages)(nil), "message.TL_message_getHistoryMessages")
	proto.RegisterType((*TLMessageGetHistoryMessagesCount)(nil), "message.TL_message_getHistoryMessagesCount")
	proto.RegisterType((*TLMessageGetPeerUserMessageId)(nil), "message.TL_message_getPeerUserMessageId")
	proto.RegisterType((*TLMessageGetPeerUserMessage)(nil), "message.TL_message_getPeerUserMessage")
	proto.RegisterType((*TLMessageSearchByMediaType)(nil), "message.TL_message_searchByMediaType")
	proto.RegisterType((*TLMessageSearch)(nil), "message.TL_message_search")
	proto.RegisterType((*TLMessageSearchGlobal)(nil), "message.TL_message_searchGlobal")
	proto.RegisterType((*TLMessageSearchByPinned)(nil), "message.TL_message_searchByPinned")
	proto.RegisterType((*TLMessageGetSearchCounter)(nil), "message.TL_message_getSearchCounter")
	proto.RegisterType((*TLMessageSearchV2)(nil), "message.TL_message_searchV2")
	proto.RegisterType((*TLMessageGetLastTwoPinnedMessageId)(nil), "message.TL_message_getLastTwoPinnedMessageId")
	proto.RegisterType((*TLMessageUpdatePinnedMessageId)(nil), "message.TL_message_updatePinnedMessageId")
	proto.RegisterType((*TLMessageGetPinnedMessageIdList)(nil), "message.TL_message_getPinnedMessageIdList")
	proto.RegisterType((*TLMessageUnPinAllMessages)(nil), "message.TL_message_unPinAllMessages")
	proto.RegisterType((*TLMessageGetUnreadMentions)(nil), "message.TL_message_getUnreadMentions")
	proto.RegisterType((*TLMessageGetUnreadMentionsCount)(nil), "message.TL_message_getUnreadMentionsCount")
	proto.RegisterType((*Vector_MessageBox)(nil), "message.Vector_MessageBox")
	proto.RegisterType((*Vector_Int)(nil), "message.Vector_Int")
}

func init() { proto.RegisterFile("message.tl.proto", fileDescriptor_854009303dbd8a76) }

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

func (this *TLMessageGetUserMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&message.TLMessageGetUserMessage{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 *TLMessageGetUserMessageList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&message.TLMessageGetUserMessageList{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "IdList: "+fmt.Sprintf("%#v", this.IdList)+",\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 *TLMessageGetUserMessageListByDataIdList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&message.TLMessageGetUserMessageListByDataIdList{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "IdList: "+fmt.Sprintf("%#v", this.IdList)+",\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 *TLMessageGetUserMessageListByDataIdUserIdList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&message.TLMessageGetUserMessageListByDataIdUserIdList{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "UserIdList: "+fmt.Sprintf("%#v", this.UserIdList)+",\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 *TLMessageGetHistoryMessages) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&message.TLMessageGetHistoryMessages{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "OffsetId: "+fmt.Sprintf("%#v", this.OffsetId)+",\n")
	s = append(s, "OffsetDate: "+fmt.Sprintf("%#v", this.OffsetDate)+",\n")
	s = append(s, "AddOffset: "+fmt.Sprintf("%#v", this.AddOffset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	s = append(s, "MaxId: "+fmt.Sprintf("%#v", this.MaxId)+",\n")
	s = append(s, "MinId: "+fmt.Sprintf("%#v", this.MinId)+",\n")
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\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 *TLMessageGetHistoryMessagesCount) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageGetHistoryMessagesCount{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 (this *TLMessageGetPeerUserMessageId) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageGetPeerUserMessageId{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerUserId: "+fmt.Sprintf("%#v", this.PeerUserId)+",\n")
	s = append(s, "MsgId: "+fmt.Sprintf("%#v", this.MsgId)+",\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 *TLMessageGetPeerUserMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageGetPeerUserMessage{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerUserId: "+fmt.Sprintf("%#v", this.PeerUserId)+",\n")
	s = append(s, "MsgId: "+fmt.Sprintf("%#v", this.MsgId)+",\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 *TLMessageSearchByMediaType) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&message.TLMessageSearchByMediaType{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "MediaType: "+fmt.Sprintf("%#v", this.MediaType)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLMessageSearch) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&message.TLMessageSearch{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "Q: "+fmt.Sprintf("%#v", this.Q)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLMessageSearchGlobal) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&message.TLMessageSearchGlobal{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "Q: "+fmt.Sprintf("%#v", this.Q)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLMessageSearchByPinned) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageSearchByPinned{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 (this *TLMessageGetSearchCounter) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&message.TLMessageGetSearchCounter{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "MediaType: "+fmt.Sprintf("%#v", this.MediaType)+",\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 *TLMessageSearchV2) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 18)
	s = append(s, "&message.TLMessageSearchV2{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "Q: "+fmt.Sprintf("%#v", this.Q)+",\n")
	s = append(s, "FromId: "+fmt.Sprintf("%#v", this.FromId)+",\n")
	s = append(s, "MinDate: "+fmt.Sprintf("%#v", this.MinDate)+",\n")
	s = append(s, "MaxDate: "+fmt.Sprintf("%#v", this.MaxDate)+",\n")
	s = append(s, "OffsetId: "+fmt.Sprintf("%#v", this.OffsetId)+",\n")
	s = append(s, "AddOffset: "+fmt.Sprintf("%#v", this.AddOffset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	s = append(s, "MaxId: "+fmt.Sprintf("%#v", this.MaxId)+",\n")
	s = append(s, "MinId: "+fmt.Sprintf("%#v", this.MinId)+",\n")
	s = append(s, "Hash: "+fmt.Sprintf("%#v", this.Hash)+",\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 *TLMessageGetLastTwoPinnedMessageId) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageGetLastTwoPinnedMessageId{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 (this *TLMessageUpdatePinnedMessageId) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&message.TLMessageUpdatePinnedMessageId{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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.Pinned != nil {
		s = append(s, "Pinned: "+fmt.Sprintf("%#v", this.Pinned)+",\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 *TLMessageGetPinnedMessageIdList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageGetPinnedMessageIdList{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 (this *TLMessageUnPinAllMessages) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageUnPinAllMessages{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 (this *TLMessageGetUnreadMentions) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&message.TLMessageGetUnreadMentions{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "OffsetId: "+fmt.Sprintf("%#v", this.OffsetId)+",\n")
	s = append(s, "AddOffset: "+fmt.Sprintf("%#v", this.AddOffset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	s = append(s, "MinId: "+fmt.Sprintf("%#v", this.MinId)+",\n")
	s = append(s, "MaxInt: "+fmt.Sprintf("%#v", this.MaxInt)+",\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 *TLMessageGetUnreadMentionsCount) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&message.TLMessageGetUnreadMentionsCount{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 (this *Vector_MessageBox) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&message.Vector_MessageBox{")
	if this.Datas != nil {
		s = append(s, "Datas: "+fmt.Sprintf("%#v", this.Datas)+",\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 *Vector_Int) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&message.Vector_Int{")
	s = append(s, "Datas: "+fmt.Sprintf("%#v", this.Datas)+",\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 valueToGoStringMessageTl(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

// RPCMessageClient is the client API for RPCMessage service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RPCMessageClient interface {
	MessageGetUserMessage(ctx context.Context, in *TLMessageGetUserMessage, opts ...grpc.CallOption) (*mtproto.MessageBox, error)
	MessageGetUserMessageList(ctx context.Context, in *TLMessageGetUserMessageList, opts ...grpc.CallOption) (*Vector_MessageBox, error)
	MessageGetUserMessageListByDataIdList(ctx context.Context, in *TLMessageGetUserMessageListByDataIdList, opts ...grpc.CallOption) (*Vector_MessageBox, error)
	MessageGetUserMessageListByDataIdUserIdList(ctx context.Context, in *TLMessageGetUserMessageListByDataIdUserIdList, opts ...grpc.CallOption) (*Vector_MessageBox, error)
	MessageGetHistoryMessages(ctx context.Context, in *TLMessageGetHistoryMessages, opts ...grpc.CallOption) (*Vector_MessageBox, error)
	MessageGetHistoryMessagesCount(ctx context.Context, in *TLMessageGetHistoryMessagesCount, opts ...grpc.CallOption) (*mtproto.Int32, error)
	MessageGetPeerUserMessageId(ctx context.Context, in *TLMessageGetPeerUserMessageId, opts ...grpc.CallOption) (*mtproto.Int32, error)
	MessageGetPeerUserMessage(ctx context.Context, in *TLMessageGetPeerUserMessage, opts ...grpc.CallOption) (*mtproto.MessageBox, error)
	MessageSearchByMediaType(ctx context.Context, in *TLMessageSearchByMediaType, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error)
	MessageSearch(ctx context.Context, in *TLMessageSearch, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error)
	MessageSearchGlobal(ctx context.Context, in *TLMessageSearchGlobal, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error)
	MessageSearchByPinned(ctx context.Context, in *TLMessageSearchByPinned, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error)
	MessageGetSearchCounter(ctx context.Context, in *TLMessageGetSearchCounter, opts ...grpc.CallOption) (*mtproto.Int32, error)
	MessageSearchV2(ctx context.Context, in *TLMessageSearchV2, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error)
	MessageGetLastTwoPinnedMessageId(ctx context.Context, in *TLMessageGetLastTwoPinnedMessageId, opts ...grpc.CallOption) (*Vector_Int, error)
	MessageUpdatePinnedMessageId(ctx context.Context, in *TLMessageUpdatePinnedMessageId, opts ...grpc.CallOption) (*mtproto.Bool, error)
	MessageGetPinnedMessageIdList(ctx context.Context, in *TLMessageGetPinnedMessageIdList, opts ...grpc.CallOption) (*Vector_Int, error)
	MessageUnPinAllMessages(ctx context.Context, in *TLMessageUnPinAllMessages, opts ...grpc.CallOption) (*Vector_Int, error)
	MessageGetUnreadMentions(ctx context.Context, in *TLMessageGetUnreadMentions, opts ...grpc.CallOption) (*Vector_MessageBox, error)
	MessageGetUnreadMentionsCount(ctx context.Context, in *TLMessageGetUnreadMentionsCount, opts ...grpc.CallOption) (*mtproto.Int32, error)
}

type rPCMessageClient struct {
	cc *grpc.ClientConn
}

func NewRPCMessageClient(cc *grpc.ClientConn) RPCMessageClient {
	return &rPCMessageClient{cc}
}

func (c *rPCMessageClient) MessageGetUserMessage(ctx context.Context, in *TLMessageGetUserMessage, opts ...grpc.CallOption) (*mtproto.MessageBox, error) {
	out := new(mtproto.MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getUserMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetUserMessageList(ctx context.Context, in *TLMessageGetUserMessageList, opts ...grpc.CallOption) (*Vector_MessageBox, error) {
	out := new(Vector_MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getUserMessageList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetUserMessageListByDataIdList(ctx context.Context, in *TLMessageGetUserMessageListByDataIdList, opts ...grpc.CallOption) (*Vector_MessageBox, error) {
	out := new(Vector_MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getUserMessageListByDataIdList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetUserMessageListByDataIdUserIdList(ctx context.Context, in *TLMessageGetUserMessageListByDataIdUserIdList, opts ...grpc.CallOption) (*Vector_MessageBox, error) {
	out := new(Vector_MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getUserMessageListByDataIdUserIdList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetHistoryMessages(ctx context.Context, in *TLMessageGetHistoryMessages, opts ...grpc.CallOption) (*Vector_MessageBox, error) {
	out := new(Vector_MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getHistoryMessages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetHistoryMessagesCount(ctx context.Context, in *TLMessageGetHistoryMessagesCount, opts ...grpc.CallOption) (*mtproto.Int32, error) {
	out := new(mtproto.Int32)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getHistoryMessagesCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetPeerUserMessageId(ctx context.Context, in *TLMessageGetPeerUserMessageId, opts ...grpc.CallOption) (*mtproto.Int32, error) {
	out := new(mtproto.Int32)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getPeerUserMessageId", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetPeerUserMessage(ctx context.Context, in *TLMessageGetPeerUserMessage, opts ...grpc.CallOption) (*mtproto.MessageBox, error) {
	out := new(mtproto.MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getPeerUserMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageSearchByMediaType(ctx context.Context, in *TLMessageSearchByMediaType, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error) {
	out := new(mtproto.MessageBoxList)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_searchByMediaType", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageSearch(ctx context.Context, in *TLMessageSearch, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error) {
	out := new(mtproto.MessageBoxList)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_search", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageSearchGlobal(ctx context.Context, in *TLMessageSearchGlobal, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error) {
	out := new(mtproto.MessageBoxList)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_searchGlobal", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageSearchByPinned(ctx context.Context, in *TLMessageSearchByPinned, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error) {
	out := new(mtproto.MessageBoxList)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_searchByPinned", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetSearchCounter(ctx context.Context, in *TLMessageGetSearchCounter, opts ...grpc.CallOption) (*mtproto.Int32, error) {
	out := new(mtproto.Int32)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getSearchCounter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageSearchV2(ctx context.Context, in *TLMessageSearchV2, opts ...grpc.CallOption) (*mtproto.MessageBoxList, error) {
	out := new(mtproto.MessageBoxList)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_searchV2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetLastTwoPinnedMessageId(ctx context.Context, in *TLMessageGetLastTwoPinnedMessageId, opts ...grpc.CallOption) (*Vector_Int, error) {
	out := new(Vector_Int)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getLastTwoPinnedMessageId", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageUpdatePinnedMessageId(ctx context.Context, in *TLMessageUpdatePinnedMessageId, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_updatePinnedMessageId", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetPinnedMessageIdList(ctx context.Context, in *TLMessageGetPinnedMessageIdList, opts ...grpc.CallOption) (*Vector_Int, error) {
	out := new(Vector_Int)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getPinnedMessageIdList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageUnPinAllMessages(ctx context.Context, in *TLMessageUnPinAllMessages, opts ...grpc.CallOption) (*Vector_Int, error) {
	out := new(Vector_Int)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_unPinAllMessages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetUnreadMentions(ctx context.Context, in *TLMessageGetUnreadMentions, opts ...grpc.CallOption) (*Vector_MessageBox, error) {
	out := new(Vector_MessageBox)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getUnreadMentions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCMessageClient) MessageGetUnreadMentionsCount(ctx context.Context, in *TLMessageGetUnreadMentionsCount, opts ...grpc.CallOption) (*mtproto.Int32, error) {
	out := new(mtproto.Int32)
	err := c.cc.Invoke(ctx, "/message.RPCMessage/message_getUnreadMentionsCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RPCMessageServer is the server API for RPCMessage service.
type RPCMessageServer interface {
	MessageGetUserMessage(context.Context, *TLMessageGetUserMessage) (*mtproto.MessageBox, error)
	MessageGetUserMessageList(context.Context, *TLMessageGetUserMessageList) (*Vector_MessageBox, error)
	MessageGetUserMessageListByDataIdList(context.Context, *TLMessageGetUserMessageListByDataIdList) (*Vector_MessageBox, error)
	MessageGetUserMessageListByDataIdUserIdList(context.Context, *TLMessageGetUserMessageListByDataIdUserIdList) (*Vector_MessageBox, error)
	MessageGetHistoryMessages(context.Context, *TLMessageGetHistoryMessages) (*Vector_MessageBox, error)
	MessageGetHistoryMessagesCount(context.Context, *TLMessageGetHistoryMessagesCount) (*mtproto.Int32, error)
	MessageGetPeerUserMessageId(context.Context, *TLMessageGetPeerUserMessageId) (*mtproto.Int32, error)
	MessageGetPeerUserMessage(context.Context, *TLMessageGetPeerUserMessage) (*mtproto.MessageBox, error)
	MessageSearchByMediaType(context.Context, *TLMessageSearchByMediaType) (*mtproto.MessageBoxList, error)
	MessageSearch(context.Context, *TLMessageSearch) (*mtproto.MessageBoxList, error)
	MessageSearchGlobal(context.Context, *TLMessageSearchGlobal) (*mtproto.MessageBoxList, error)
	MessageSearchByPinned(context.Context, *TLMessageSearchByPinned) (*mtproto.MessageBoxList, error)
	MessageGetSearchCounter(context.Context, *TLMessageGetSearchCounter) (*mtproto.Int32, error)
	MessageSearchV2(context.Context, *TLMessageSearchV2) (*mtproto.MessageBoxList, error)
	MessageGetLastTwoPinnedMessageId(context.Context, *TLMessageGetLastTwoPinnedMessageId) (*Vector_Int, error)
	MessageUpdatePinnedMessageId(context.Context, *TLMessageUpdatePinnedMessageId) (*mtproto.Bool, error)
	MessageGetPinnedMessageIdList(context.Context, *TLMessageGetPinnedMessageIdList) (*Vector_Int, error)
	MessageUnPinAllMessages(context.Context, *TLMessageUnPinAllMessages) (*Vector_Int, error)
	MessageGetUnreadMentions(context.Context, *TLMessageGetUnreadMentions) (*Vector_MessageBox, error)
	MessageGetUnreadMentionsCount(context.Context, *TLMessageGetUnreadMentionsCount) (*mtproto.Int32, error)
}

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

func (*UnimplementedRPCMessageServer) MessageGetUserMessage(ctx context.Context, req *TLMessageGetUserMessage) (*mtproto.MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetUserMessage not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetUserMessageList(ctx context.Context, req *TLMessageGetUserMessageList) (*Vector_MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetUserMessageList not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetUserMessageListByDataIdList(ctx context.Context, req *TLMessageGetUserMessageListByDataIdList) (*Vector_MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetUserMessageListByDataIdList not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetUserMessageListByDataIdUserIdList(ctx context.Context, req *TLMessageGetUserMessageListByDataIdUserIdList) (*Vector_MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetUserMessageListByDataIdUserIdList not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetHistoryMessages(ctx context.Context, req *TLMessageGetHistoryMessages) (*Vector_MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetHistoryMessages not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetHistoryMessagesCount(ctx context.Context, req *TLMessageGetHistoryMessagesCount) (*mtproto.Int32, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetHistoryMessagesCount not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetPeerUserMessageId(ctx context.Context, req *TLMessageGetPeerUserMessageId) (*mtproto.Int32, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetPeerUserMessageId not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetPeerUserMessage(ctx context.Context, req *TLMessageGetPeerUserMessage) (*mtproto.MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetPeerUserMessage not implemented")
}
func (*UnimplementedRPCMessageServer) MessageSearchByMediaType(ctx context.Context, req *TLMessageSearchByMediaType) (*mtproto.MessageBoxList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageSearchByMediaType not implemented")
}
func (*UnimplementedRPCMessageServer) MessageSearch(ctx context.Context, req *TLMessageSearch) (*mtproto.MessageBoxList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageSearch not implemented")
}
func (*UnimplementedRPCMessageServer) MessageSearchGlobal(ctx context.Context, req *TLMessageSearchGlobal) (*mtproto.MessageBoxList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageSearchGlobal not implemented")
}
func (*UnimplementedRPCMessageServer) MessageSearchByPinned(ctx context.Context, req *TLMessageSearchByPinned) (*mtproto.MessageBoxList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageSearchByPinned not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetSearchCounter(ctx context.Context, req *TLMessageGetSearchCounter) (*mtproto.Int32, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetSearchCounter not implemented")
}
func (*UnimplementedRPCMessageServer) MessageSearchV2(ctx context.Context, req *TLMessageSearchV2) (*mtproto.MessageBoxList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageSearchV2 not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetLastTwoPinnedMessageId(ctx context.Context, req *TLMessageGetLastTwoPinnedMessageId) (*Vector_Int, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetLastTwoPinnedMessageId not implemented")
}
func (*UnimplementedRPCMessageServer) MessageUpdatePinnedMessageId(ctx context.Context, req *TLMessageUpdatePinnedMessageId) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageUpdatePinnedMessageId not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetPinnedMessageIdList(ctx context.Context, req *TLMessageGetPinnedMessageIdList) (*Vector_Int, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetPinnedMessageIdList not implemented")
}
func (*UnimplementedRPCMessageServer) MessageUnPinAllMessages(ctx context.Context, req *TLMessageUnPinAllMessages) (*Vector_Int, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageUnPinAllMessages not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetUnreadMentions(ctx context.Context, req *TLMessageGetUnreadMentions) (*Vector_MessageBox, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetUnreadMentions not implemented")
}
func (*UnimplementedRPCMessageServer) MessageGetUnreadMentionsCount(ctx context.Context, req *TLMessageGetUnreadMentionsCount) (*mtproto.Int32, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageGetUnreadMentionsCount not implemented")
}

func RegisterRPCMessageServer(s *grpc.Server, srv RPCMessageServer) {
	s.RegisterService(&_RPCMessage_serviceDesc, srv)
}

func _RPCMessage_MessageGetUserMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetUserMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetUserMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetUserMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetUserMessage(ctx, req.(*TLMessageGetUserMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetUserMessageList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetUserMessageList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetUserMessageList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetUserMessageList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetUserMessageList(ctx, req.(*TLMessageGetUserMessageList))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetUserMessageListByDataIdList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetUserMessageListByDataIdList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetUserMessageListByDataIdList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetUserMessageListByDataIdList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetUserMessageListByDataIdList(ctx, req.(*TLMessageGetUserMessageListByDataIdList))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetUserMessageListByDataIdUserIdList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetUserMessageListByDataIdUserIdList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetUserMessageListByDataIdUserIdList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetUserMessageListByDataIdUserIdList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetUserMessageListByDataIdUserIdList(ctx, req.(*TLMessageGetUserMessageListByDataIdUserIdList))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetHistoryMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetHistoryMessages)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetHistoryMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetHistoryMessages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetHistoryMessages(ctx, req.(*TLMessageGetHistoryMessages))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetHistoryMessagesCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetHistoryMessagesCount)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetHistoryMessagesCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetHistoryMessagesCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetHistoryMessagesCount(ctx, req.(*TLMessageGetHistoryMessagesCount))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetPeerUserMessageId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetPeerUserMessageId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetPeerUserMessageId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetPeerUserMessageId",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetPeerUserMessageId(ctx, req.(*TLMessageGetPeerUserMessageId))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetPeerUserMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetPeerUserMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetPeerUserMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetPeerUserMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetPeerUserMessage(ctx, req.(*TLMessageGetPeerUserMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageSearchByMediaType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageSearchByMediaType)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageSearchByMediaType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageSearchByMediaType",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageSearchByMediaType(ctx, req.(*TLMessageSearchByMediaType))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageSearch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageSearch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageSearch(ctx, req.(*TLMessageSearch))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageSearchGlobal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageSearchGlobal)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageSearchGlobal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageSearchGlobal",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageSearchGlobal(ctx, req.(*TLMessageSearchGlobal))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageSearchByPinned_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageSearchByPinned)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageSearchByPinned(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageSearchByPinned",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageSearchByPinned(ctx, req.(*TLMessageSearchByPinned))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetSearchCounter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetSearchCounter)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetSearchCounter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetSearchCounter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetSearchCounter(ctx, req.(*TLMessageGetSearchCounter))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageSearchV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageSearchV2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageSearchV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageSearchV2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageSearchV2(ctx, req.(*TLMessageSearchV2))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetLastTwoPinnedMessageId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetLastTwoPinnedMessageId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetLastTwoPinnedMessageId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetLastTwoPinnedMessageId",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetLastTwoPinnedMessageId(ctx, req.(*TLMessageGetLastTwoPinnedMessageId))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageUpdatePinnedMessageId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageUpdatePinnedMessageId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageUpdatePinnedMessageId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageUpdatePinnedMessageId",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageUpdatePinnedMessageId(ctx, req.(*TLMessageUpdatePinnedMessageId))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetPinnedMessageIdList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetPinnedMessageIdList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetPinnedMessageIdList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetPinnedMessageIdList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetPinnedMessageIdList(ctx, req.(*TLMessageGetPinnedMessageIdList))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageUnPinAllMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageUnPinAllMessages)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageUnPinAllMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageUnPinAllMessages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageUnPinAllMessages(ctx, req.(*TLMessageUnPinAllMessages))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetUnreadMentions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetUnreadMentions)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetUnreadMentions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetUnreadMentions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetUnreadMentions(ctx, req.(*TLMessageGetUnreadMentions))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCMessage_MessageGetUnreadMentionsCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLMessageGetUnreadMentionsCount)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCMessageServer).MessageGetUnreadMentionsCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/message.RPCMessage/MessageGetUnreadMentionsCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCMessageServer).MessageGetUnreadMentionsCount(ctx, req.(*TLMessageGetUnreadMentionsCount))
	}
	return interceptor(ctx, in, info, handler)
}

var _RPCMessage_serviceDesc = grpc.ServiceDesc{
	ServiceName: "message.RPCMessage",
	HandlerType: (*RPCMessageServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "message_getUserMessage",
			Handler:    _RPCMessage_MessageGetUserMessage_Handler,
		},
		{
			MethodName: "message_getUserMessageList",
			Handler:    _RPCMessage_MessageGetUserMessageList_Handler,
		},
		{
			MethodName: "message_getUserMessageListByDataIdList",
			Handler:    _RPCMessage_MessageGetUserMessageListByDataIdList_Handler,
		},
		{
			MethodName: "message_getUserMessageListByDataIdUserIdList",
			Handler:    _RPCMessage_MessageGetUserMessageListByDataIdUserIdList_Handler,
		},
		{
			MethodName: "message_getHistoryMessages",
			Handler:    _RPCMessage_MessageGetHistoryMessages_Handler,
		},
		{
			MethodName: "message_getHistoryMessagesCount",
			Handler:    _RPCMessage_MessageGetHistoryMessagesCount_Handler,
		},
		{
			MethodName: "message_getPeerUserMessageId",
			Handler:    _RPCMessage_MessageGetPeerUserMessageId_Handler,
		},
		{
			MethodName: "message_getPeerUserMessage",
			Handler:    _RPCMessage_MessageGetPeerUserMessage_Handler,
		},
		{
			MethodName: "message_searchByMediaType",
			Handler:    _RPCMessage_MessageSearchByMediaType_Handler,
		},
		{
			MethodName: "message_search",
			Handler:    _RPCMessage_MessageSearch_Handler,
		},
		{
			MethodName: "message_searchGlobal",
			Handler:    _RPCMessage_MessageSearchGlobal_Handler,
		},
		{
			MethodName: "message_searchByPinned",
			Handler:    _RPCMessage_MessageSearchByPinned_Handler,
		},
		{
			MethodName: "message_getSearchCounter",
			Handler:    _RPCMessage_MessageGetSearchCounter_Handler,
		},
		{
			MethodName: "message_searchV2",
			Handler:    _RPCMessage_MessageSearchV2_Handler,
		},
		{
			MethodName: "message_getLastTwoPinnedMessageId",
			Handler:    _RPCMessage_MessageGetLastTwoPinnedMessageId_Handler,
		},
		{
			MethodName: "message_updatePinnedMessageId",
			Handler:    _RPCMessage_MessageUpdatePinnedMessageId_Handler,
		},
		{
			MethodName: "message_getPinnedMessageIdList",
			Handler:    _RPCMessage_MessageGetPinnedMessageIdList_Handler,
		},
		{
			MethodName: "message_unPinAllMessages",
			Handler:    _RPCMessage_MessageUnPinAllMessages_Handler,
		},
		{
			MethodName: "message_getUnreadMentions",
			Handler:    _RPCMessage_MessageGetUnreadMentions_Handler,
		},
		{
			MethodName: "message_getUnreadMentionsCount",
			Handler:    _RPCMessage_MessageGetUnreadMentionsCount_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "message.tl.proto",
}

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

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

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

func (m *TLMessageGetUserMessageList) 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.IdList) > 0 {
		dAtA2 := make([]byte, len(m.IdList)*10)
		var j1 int
		for _, num1 := range m.IdList {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintMessageTl(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageGetUserMessageListByDataIdList) 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.IdList) > 0 {
		dAtA4 := make([]byte, len(m.IdList)*10)
		var j3 int
		for _, num1 := range m.IdList {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA4[:j3])
		i = encodeVarintMessageTl(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageGetUserMessageListByDataIdUserIdList) 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.UserIdList) > 0 {
		dAtA6 := make([]byte, len(m.UserIdList)*10)
		var j5 int
		for _, num1 := range m.UserIdList {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintMessageTl(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x22
	}
	if m.Id != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageGetHistoryMessages) 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.Hash != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Hash))
		i--
		dAtA[i] = 0x60
	}
	if m.MinId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MinId))
		i--
		dAtA[i] = 0x58
	}
	if m.MaxId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MaxId))
		i--
		dAtA[i] = 0x50
	}
	if m.Limit != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x48
	}
	if m.AddOffset != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.AddOffset))
		i--
		dAtA[i] = 0x40
	}
	if m.OffsetDate != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.OffsetDate))
		i--
		dAtA[i] = 0x38
	}
	if m.OffsetId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.OffsetId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerType != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TLMessageGetPeerUserMessageId) 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.MsgId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MsgId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerUserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerUserId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageGetPeerUserMessage) 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.MsgId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MsgId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerUserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerUserId))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageSearchByMediaType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Limit != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x40
	}
	if m.Offset != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x38
	}
	if m.MediaType != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MediaType))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerType != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageSearch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Limit != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x40
	}
	if m.Offset != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Q) > 0 {
		i -= len(m.Q)
		copy(dAtA[i:], m.Q)
		i = encodeVarintMessageTl(dAtA, i, uint64(len(m.Q)))
		i--
		dAtA[i] = 0x32
	}
	if m.PeerId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerType != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLMessageSearchGlobal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Limit != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x30
	}
	if m.Offset != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Q) > 0 {
		i -= len(m.Q)
		copy(dAtA[i:], m.Q)
		i = encodeVarintMessageTl(dAtA, i, uint64(len(m.Q)))
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *TLMessageSearchV2) 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.Hash != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Hash))
		i--
		dAtA[i] = 0x78
	}
	if m.MinId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MinId))
		i--
		dAtA[i] = 0x70
	}
	if m.MaxId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MaxId))
		i--
		dAtA[i] = 0x68
	}
	if m.Limit != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x60
	}
	if m.AddOffset != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.AddOffset))
		i--
		dAtA[i] = 0x58
	}
	if m.OffsetId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.OffsetId))
		i--
		dAtA[i] = 0x50
	}
	if m.MaxDate != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MaxDate))
		i--
		dAtA[i] = 0x48
	}
	if m.MinDate != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MinDate))
		i--
		dAtA[i] = 0x40
	}
	if m.FromId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.FromId))
		i--
		dAtA[i] = 0x38
	}
	if len(m.Q) > 0 {
		i -= len(m.Q)
		copy(dAtA[i:], m.Q)
		i = encodeVarintMessageTl(dAtA, i, uint64(len(m.Q)))
		i--
		dAtA[i] = 0x32
	}
	if m.PeerId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerType != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func (m *TLMessageGetUnreadMentions) 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.MaxInt != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MaxInt))
		i--
		dAtA[i] = 0x50
	}
	if m.MinId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.MinId))
		i--
		dAtA[i] = 0x48
	}
	if m.Limit != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x40
	}
	if m.AddOffset != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.AddOffset))
		i--
		dAtA[i] = 0x38
	}
	if m.OffsetId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.OffsetId))
		i--
		dAtA[i] = 0x30
	}
	if m.PeerId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x28
	}
	if m.PeerType != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x20
	}
	if m.UserId != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintMessageTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *Vector_MessageBox) 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.Datas) > 0 {
		for iNdEx := len(m.Datas) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Datas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMessageTl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Vector_Int) 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.Datas) > 0 {
		dAtA9 := make([]byte, len(m.Datas)*10)
		var j8 int
		for _, num1 := range m.Datas {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		i -= j8
		copy(dAtA[i:], dAtA9[:j8])
		i = encodeVarintMessageTl(dAtA, i, uint64(j8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TLMessageGetUserMessageListByDataIdUserIdList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.Id != 0 {
		n += 1 + sovMessageTl(uint64(m.Id))
	}
	if len(m.UserIdList) > 0 {
		l = 0
		for _, e := range m.UserIdList {
			l += sovMessageTl(uint64(e))
		}
		n += 1 + sovMessageTl(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMessageGetHistoryMessages) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerId))
	}
	if m.OffsetId != 0 {
		n += 1 + sovMessageTl(uint64(m.OffsetId))
	}
	if m.OffsetDate != 0 {
		n += 1 + sovMessageTl(uint64(m.OffsetDate))
	}
	if m.AddOffset != 0 {
		n += 1 + sovMessageTl(uint64(m.AddOffset))
	}
	if m.Limit != 0 {
		n += 1 + sovMessageTl(uint64(m.Limit))
	}
	if m.MaxId != 0 {
		n += 1 + sovMessageTl(uint64(m.MaxId))
	}
	if m.MinId != 0 {
		n += 1 + sovMessageTl(uint64(m.MinId))
	}
	if m.Hash != 0 {
		n += 1 + sovMessageTl(uint64(m.Hash))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *TLMessageGetPeerUserMessageId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerUserId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerUserId))
	}
	if m.MsgId != 0 {
		n += 1 + sovMessageTl(uint64(m.MsgId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMessageGetPeerUserMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerUserId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerUserId))
	}
	if m.MsgId != 0 {
		n += 1 + sovMessageTl(uint64(m.MsgId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMessageSearchByMediaType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerId))
	}
	if m.MediaType != 0 {
		n += 1 + sovMessageTl(uint64(m.MediaType))
	}
	if m.Offset != 0 {
		n += 1 + sovMessageTl(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovMessageTl(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMessageSearch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerId))
	}
	l = len(m.Q)
	if l > 0 {
		n += 1 + l + sovMessageTl(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovMessageTl(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovMessageTl(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLMessageSearchGlobal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	l = len(m.Q)
	if l > 0 {
		n += 1 + l + sovMessageTl(uint64(l))
	}
	if m.Offset != 0 {
		n += 1 + sovMessageTl(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovMessageTl(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *TLMessageSearchV2) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerId))
	}
	l = len(m.Q)
	if l > 0 {
		n += 1 + l + sovMessageTl(uint64(l))
	}
	if m.FromId != 0 {
		n += 1 + sovMessageTl(uint64(m.FromId))
	}
	if m.MinDate != 0 {
		n += 1 + sovMessageTl(uint64(m.MinDate))
	}
	if m.MaxDate != 0 {
		n += 1 + sovMessageTl(uint64(m.MaxDate))
	}
	if m.OffsetId != 0 {
		n += 1 + sovMessageTl(uint64(m.OffsetId))
	}
	if m.AddOffset != 0 {
		n += 1 + sovMessageTl(uint64(m.AddOffset))
	}
	if m.Limit != 0 {
		n += 1 + sovMessageTl(uint64(m.Limit))
	}
	if m.MaxId != 0 {
		n += 1 + sovMessageTl(uint64(m.MaxId))
	}
	if m.MinId != 0 {
		n += 1 + sovMessageTl(uint64(m.MinId))
	}
	if m.Hash != 0 {
		n += 1 + sovMessageTl(uint64(m.Hash))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func (m *TLMessageGetUnreadMentions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovMessageTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovMessageTl(uint64(m.UserId))
	}
	if m.PeerType != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerType))
	}
	if m.PeerId != 0 {
		n += 1 + sovMessageTl(uint64(m.PeerId))
	}
	if m.OffsetId != 0 {
		n += 1 + sovMessageTl(uint64(m.OffsetId))
	}
	if m.AddOffset != 0 {
		n += 1 + sovMessageTl(uint64(m.AddOffset))
	}
	if m.Limit != 0 {
		n += 1 + sovMessageTl(uint64(m.Limit))
	}
	if m.MinId != 0 {
		n += 1 + sovMessageTl(uint64(m.MinId))
	}
	if m.MaxInt != 0 {
		n += 1 + sovMessageTl(uint64(m.MaxInt))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Vector_MessageBox) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Datas) > 0 {
		for _, e := range m.Datas {
			l = e.Size()
			n += 1 + l + sovMessageTl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Vector_Int) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Datas) > 0 {
		l = 0
		for _, e := range m.Datas {
			l += sovMessageTl(uint64(e))
		}
		n += 1 + sovMessageTl(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovMessageTl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMessageTl(x uint64) (n int) {
	return sovMessageTl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TLMessageGetUserMessage) 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 ErrIntOverflowMessageTl
			}
			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_message_getUserMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getUserMessage: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetUserMessageList) 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 ErrIntOverflowMessageTl
			}
			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_message_getUserMessageList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getUserMessageList: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IdList = append(m.IdList, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMessageTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMessageTl
				}
				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.IdList) == 0 {
					m.IdList = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessageTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IdList = append(m.IdList, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IdList", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetUserMessageListByDataIdList) 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 ErrIntOverflowMessageTl
			}
			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_message_getUserMessageListByDataIdList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getUserMessageListByDataIdList: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IdList = append(m.IdList, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMessageTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMessageTl
				}
				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.IdList) == 0 {
					m.IdList = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessageTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IdList = append(m.IdList, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IdList", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetUserMessageListByDataIdUserIdList) 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 ErrIntOverflowMessageTl
			}
			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_message_getUserMessageListByDataIdUserIdList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getUserMessageListByDataIdUserIdList: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.UserIdList = append(m.UserIdList, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMessageTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMessageTl
				}
				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.UserIdList) == 0 {
					m.UserIdList = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessageTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.UserIdList = append(m.UserIdList, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field UserIdList", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetHistoryMessages) 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 ErrIntOverflowMessageTl
			}
			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_message_getHistoryMessages: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getHistoryMessages: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OffsetId", wireType)
			}
			m.OffsetId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OffsetId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OffsetDate", wireType)
			}
			m.OffsetDate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OffsetDate |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddOffset", wireType)
			}
			m.AddOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddOffset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinId", wireType)
			}
			m.MinId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			m.Hash = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hash |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetHistoryMessagesCount) 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 ErrIntOverflowMessageTl
			}
			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_message_getHistoryMessagesCount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getHistoryMessagesCount: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetPeerUserMessageId) 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 ErrIntOverflowMessageTl
			}
			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_message_getPeerUserMessageId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getPeerUserMessageId: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerUserId", wireType)
			}
			m.PeerUserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerUserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType)
			}
			m.MsgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetPeerUserMessage) 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 ErrIntOverflowMessageTl
			}
			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_message_getPeerUserMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getPeerUserMessage: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerUserId", wireType)
			}
			m.PeerUserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerUserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgId", wireType)
			}
			m.MsgId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageSearchByMediaType) 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 ErrIntOverflowMessageTl
			}
			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_message_searchByMediaType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_searchByMediaType: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MediaType", wireType)
			}
			m.MediaType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MediaType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageSearch) 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 ErrIntOverflowMessageTl
			}
			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_message_search: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_search: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Q", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				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 ErrInvalidLengthMessageTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessageTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Q = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageSearchGlobal) 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 ErrIntOverflowMessageTl
			}
			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_message_searchGlobal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_searchGlobal: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Q", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				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 ErrInvalidLengthMessageTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessageTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Q = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageSearchByPinned) 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 ErrIntOverflowMessageTl
			}
			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_message_searchByPinned: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_searchByPinned: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetSearchCounter) 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 ErrIntOverflowMessageTl
			}
			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_message_getSearchCounter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getSearchCounter: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MediaType", wireType)
			}
			m.MediaType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MediaType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageSearchV2) 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 ErrIntOverflowMessageTl
			}
			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_message_searchV2: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_searchV2: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Q", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				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 ErrInvalidLengthMessageTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessageTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Q = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromId", wireType)
			}
			m.FromId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FromId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinDate", wireType)
			}
			m.MinDate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinDate |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxDate", wireType)
			}
			m.MaxDate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxDate |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OffsetId", wireType)
			}
			m.OffsetId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OffsetId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddOffset", wireType)
			}
			m.AddOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddOffset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinId", wireType)
			}
			m.MinId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			m.Hash = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hash |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetLastTwoPinnedMessageId) 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 ErrIntOverflowMessageTl
			}
			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_message_getLastTwoPinnedMessageId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getLastTwoPinnedMessageId: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageUpdatePinnedMessageId) 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 ErrIntOverflowMessageTl
			}
			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_message_updatePinnedMessageId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_updatePinnedMessageId: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pinned", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessageTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessageTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pinned == nil {
				m.Pinned = &mtproto.Bool{}
			}
			if err := m.Pinned.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetPinnedMessageIdList) 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 ErrIntOverflowMessageTl
			}
			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_message_getPinnedMessageIdList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getPinnedMessageIdList: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageUnPinAllMessages) 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 ErrIntOverflowMessageTl
			}
			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_message_unPinAllMessages: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetUnreadMentions) 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 ErrIntOverflowMessageTl
			}
			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_message_getUnreadMentions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getUnreadMentions: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OffsetId", wireType)
			}
			m.OffsetId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OffsetId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddOffset", wireType)
			}
			m.AddOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AddOffset |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinId", wireType)
			}
			m.MinId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxInt", wireType)
			}
			m.MaxInt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxInt |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *TLMessageGetUnreadMentionsCount) 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 ErrIntOverflowMessageTl
			}
			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_message_getUnreadMentionsCount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_message_getUnreadMentionsCount: 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 ErrIntOverflowMessageTl
				}
				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 ErrIntOverflowMessageTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowMessageTl
				}
				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 := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *Vector_MessageBox) 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 ErrIntOverflowMessageTl
			}
			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: Vector_MessageBox: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vector_MessageBox: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Datas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessageTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessageTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessageTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Datas = append(m.Datas, &mtproto.MessageBox{})
			if err := m.Datas[len(m.Datas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 *Vector_Int) 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 ErrIntOverflowMessageTl
			}
			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: Vector_Int: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vector_Int: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Datas = append(m.Datas, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMessageTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthMessageTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthMessageTl
				}
				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.Datas) == 0 {
					m.Datas = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMessageTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Datas = append(m.Datas, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Datas", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessageTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessageTl
			}
			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 skipMessageTl(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, ErrIntOverflowMessageTl
			}
			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, ErrIntOverflowMessageTl
				}
				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, ErrIntOverflowMessageTl
				}
				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, ErrInvalidLengthMessageTl
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMessageTl
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMessageTl
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMessageTl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessageTl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMessageTl = fmt.Errorf("proto: unexpected end of group")
)