username.tl.pb.go

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

package username

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_usernameNotExisted             TLConstructor = -885195923
	CRC32_usernameExisted                TLConstructor = -1394084659
	CRC32_usernameExistedNotMe           TLConstructor = -803256399
	CRC32_usernameExistedIsMe            TLConstructor = -2024900751
	CRC32_usernameData                   TLConstructor = -1438646081
	CRC32_username_getAccountUsername    TLConstructor = 154073301
	CRC32_username_checkAccountUsername  TLConstructor = 1240985861
	CRC32_username_getChannelUsername    TLConstructor = -2038134827
	CRC32_username_checkChannelUsername  TLConstructor = 651476637
	CRC32_username_updateUsernameByPeer  TLConstructor = 1718205916
	CRC32_username_checkUsername         TLConstructor = 684369621
	CRC32_username_updateUsername        TLConstructor = 1389777971
	CRC32_username_deleteUsername        TLConstructor = -1065913464
	CRC32_username_resolveUsername       TLConstructor = 2008689862
	CRC32_username_getListByUsernameList TLConstructor = 1218942797
	CRC32_username_deleteUsernameByPeer  TLConstructor = 507822189
	CRC32_username_search                TLConstructor = -391798010
)

var TLConstructor_name = map[int32]string{
	0:           "CRC32_UNKNOWN",
	-885195923:  "CRC32_usernameNotExisted",
	-1394084659: "CRC32_usernameExisted",
	-803256399:  "CRC32_usernameExistedNotMe",
	-2024900751: "CRC32_usernameExistedIsMe",
	-1438646081: "CRC32_usernameData",
	154073301:   "CRC32_username_getAccountUsername",
	1240985861:  "CRC32_username_checkAccountUsername",
	-2038134827: "CRC32_username_getChannelUsername",
	651476637:   "CRC32_username_checkChannelUsername",
	1718205916:  "CRC32_username_updateUsernameByPeer",
	684369621:   "CRC32_username_checkUsername",
	1389777971:  "CRC32_username_updateUsername",
	-1065913464: "CRC32_username_deleteUsername",
	2008689862:  "CRC32_username_resolveUsername",
	1218942797:  "CRC32_username_getListByUsernameList",
	507822189:   "CRC32_username_deleteUsernameByPeer",
	-391798010:  "CRC32_username_search",
}

var TLConstructor_value = map[string]int32{
	"CRC32_UNKNOWN":                        0,
	"CRC32_usernameNotExisted":             -885195923,
	"CRC32_usernameExisted":                -1394084659,
	"CRC32_usernameExistedNotMe":           -803256399,
	"CRC32_usernameExistedIsMe":            -2024900751,
	"CRC32_usernameData":                   -1438646081,
	"CRC32_username_getAccountUsername":    154073301,
	"CRC32_username_checkAccountUsername":  1240985861,
	"CRC32_username_getChannelUsername":    -2038134827,
	"CRC32_username_checkChannelUsername":  651476637,
	"CRC32_username_updateUsernameByPeer":  1718205916,
	"CRC32_username_checkUsername":         684369621,
	"CRC32_username_updateUsername":        1389777971,
	"CRC32_username_deleteUsername":        -1065913464,
	"CRC32_username_resolveUsername":       2008689862,
	"CRC32_username_getListByUsernameList": 1218942797,
	"CRC32_username_deleteUsernameByPeer":  507822189,
	"CRC32_username_search":                -391798010,
}

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

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

// UsernameData <--
//  + TL_usernameData
//
type UsernameData struct {
	PredicateName        string        `protobuf:"bytes,1,opt,name=predicate_name,json=predicateName,proto3" json:"predicate_name,omitempty"`
	Constructor          TLConstructor `protobuf:"varint,2,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	Username             string        `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	Peer                 *mtproto.Peer `protobuf:"bytes,4,opt,name=peer,proto3" json:"peer,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_UsernameData proto.InternalMessageInfo

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

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

func (m *UsernameData) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *UsernameData) GetPeer() *mtproto.Peer {
	if m != nil {
		return m.Peer
	}
	return nil
}

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

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

var xxx_messageInfo_TLUsernameData proto.InternalMessageInfo

func (m *TLUsernameData) GetData2() *UsernameData {
	if m != nil {
		return m.Data2
	}
	return nil
}

// UsernameExist <--
//  + TL_usernameNotExisted
//  + TL_usernameExisted
//  + TL_usernameExistedNotMe
//  + TL_usernameExistedIsMe
//
type UsernameExist struct {
	PredicateName        string        `protobuf:"bytes,1,opt,name=predicate_name,json=predicateName,proto3" json:"predicate_name,omitempty"`
	Constructor          TLConstructor `protobuf:"varint,2,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_UsernameExist proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_TLUsernameNotExisted proto.InternalMessageInfo

func (m *TLUsernameNotExisted) GetData2() *UsernameExist {
	if m != nil {
		return m.Data2
	}
	return nil
}

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

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

var xxx_messageInfo_TLUsernameExisted proto.InternalMessageInfo

func (m *TLUsernameExisted) GetData2() *UsernameExist {
	if m != nil {
		return m.Data2
	}
	return nil
}

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

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

var xxx_messageInfo_TLUsernameExistedNotMe proto.InternalMessageInfo

func (m *TLUsernameExistedNotMe) GetData2() *UsernameExist {
	if m != nil {
		return m.Data2
	}
	return nil
}

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

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

var xxx_messageInfo_TLUsernameExistedIsMe proto.InternalMessageInfo

func (m *TLUsernameExistedIsMe) GetData2() *UsernameExist {
	if m != nil {
		return m.Data2
	}
	return nil
}

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

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

var xxx_messageInfo_TLUsernameGetAccountUsername proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_TLUsernameCheckAccountUsername proto.InternalMessageInfo

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

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

func (m *TLUsernameCheckAccountUsername) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameGetChannelUsername struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	ChannelId            int64         `protobuf:"varint,3,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameGetChannelUsername proto.InternalMessageInfo

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

func (m *TLUsernameGetChannelUsername) GetChannelId() int64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

//--------------------------------------------------------------------------------------------
type TLUsernameCheckChannelUsername struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	ChannelId            int64         `protobuf:"varint,3,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	Username             string        `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameCheckChannelUsername proto.InternalMessageInfo

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

func (m *TLUsernameCheckChannelUsername) GetChannelId() int64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *TLUsernameCheckChannelUsername) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameUpdateUsernameByPeer struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	PeerType             int32         `protobuf:"varint,3,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,4,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Username             string        `protobuf:"bytes,5,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameUpdateUsernameByPeer proto.InternalMessageInfo

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

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

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

func (m *TLUsernameUpdateUsernameByPeer) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameCheckUsername struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	Username             string        `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameCheckUsername proto.InternalMessageInfo

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

func (m *TLUsernameCheckUsername) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameUpdateUsername struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	PeerType             int32         `protobuf:"varint,3,opt,name=peer_type,json=peerType,proto3" json:"peer_type,omitempty"`
	PeerId               int64         `protobuf:"varint,4,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	Username             string        `protobuf:"bytes,5,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameUpdateUsername proto.InternalMessageInfo

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

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

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

func (m *TLUsernameUpdateUsername) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameDeleteUsername struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	Username             string        `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameDeleteUsername proto.InternalMessageInfo

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

func (m *TLUsernameDeleteUsername) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameResolveUsername struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	Username             string        `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameResolveUsername proto.InternalMessageInfo

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

func (m *TLUsernameResolveUsername) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

//--------------------------------------------------------------------------------------------
type TLUsernameGetListByUsernameList struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	Names                []string      `protobuf:"bytes,3,rep,name=names,proto3" json:"names,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameGetListByUsernameList proto.InternalMessageInfo

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

func (m *TLUsernameGetListByUsernameList) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

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

var xxx_messageInfo_TLUsernameDeleteUsernameByPeer proto.InternalMessageInfo

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

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

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

//--------------------------------------------------------------------------------------------
type TLUsernameSearch struct {
	Constructor          TLConstructor `protobuf:"varint,1,opt,name=constructor,proto3,enum=username.TLConstructor" json:"constructor,omitempty"`
	Q                    string        `protobuf:"bytes,3,opt,name=q,proto3" json:"q,omitempty"`
	ExcludedContacts     []int64       `protobuf:"varint,4,rep,packed,name=excluded_contacts,json=excludedContacts,proto3" json:"excluded_contacts,omitempty"`
	Limit                int32         `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_TLUsernameSearch proto.InternalMessageInfo

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

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

func (m *TLUsernameSearch) GetExcludedContacts() []int64 {
	if m != nil {
		return m.ExcludedContacts
	}
	return nil
}

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

//--------------------------------------------------------------------------------------------
// Vector api result type
type Vector_UsernameData struct {
	Datas                []*UsernameData `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_UsernameData) Reset()         { *m = Vector_UsernameData{} }
func (m *Vector_UsernameData) String() string { return proto.CompactTextString(m) }
func (*Vector_UsernameData) ProtoMessage()    {}
func (*Vector_UsernameData) Descriptor() ([]byte, []int) {
	return fileDescriptor_177d8690bd27445f, []int{19}
}
func (m *Vector_UsernameData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Vector_UsernameData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Vector_UsernameData.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_UsernameData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vector_UsernameData.Merge(m, src)
}
func (m *Vector_UsernameData) XXX_Size() int {
	return m.Size()
}
func (m *Vector_UsernameData) XXX_DiscardUnknown() {
	xxx_messageInfo_Vector_UsernameData.DiscardUnknown(m)
}

var xxx_messageInfo_Vector_UsernameData proto.InternalMessageInfo

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

func init() {
	proto.RegisterEnum("username.TLConstructor", TLConstructor_name, TLConstructor_value)
	proto.RegisterType((*UsernameData)(nil), "username.UsernameData")
	proto.RegisterType((*TLUsernameData)(nil), "username.TL_usernameData")
	proto.RegisterType((*UsernameExist)(nil), "username.UsernameExist")
	proto.RegisterType((*TLUsernameNotExisted)(nil), "username.TL_usernameNotExisted")
	proto.RegisterType((*TLUsernameExisted)(nil), "username.TL_usernameExisted")
	proto.RegisterType((*TLUsernameExistedNotMe)(nil), "username.TL_usernameExistedNotMe")
	proto.RegisterType((*TLUsernameExistedIsMe)(nil), "username.TL_usernameExistedIsMe")
	proto.RegisterType((*TLUsernameGetAccountUsername)(nil), "username.TL_username_getAccountUsername")
	proto.RegisterType((*TLUsernameCheckAccountUsername)(nil), "username.TL_username_checkAccountUsername")
	proto.RegisterType((*TLUsernameGetChannelUsername)(nil), "username.TL_username_getChannelUsername")
	proto.RegisterType((*TLUsernameCheckChannelUsername)(nil), "username.TL_username_checkChannelUsername")
	proto.RegisterType((*TLUsernameUpdateUsernameByPeer)(nil), "username.TL_username_updateUsernameByPeer")
	proto.RegisterType((*TLUsernameCheckUsername)(nil), "username.TL_username_checkUsername")
	proto.RegisterType((*TLUsernameUpdateUsername)(nil), "username.TL_username_updateUsername")
	proto.RegisterType((*TLUsernameDeleteUsername)(nil), "username.TL_username_deleteUsername")
	proto.RegisterType((*TLUsernameResolveUsername)(nil), "username.TL_username_resolveUsername")
	proto.RegisterType((*TLUsernameGetListByUsernameList)(nil), "username.TL_username_getListByUsernameList")
	proto.RegisterType((*TLUsernameDeleteUsernameByPeer)(nil), "username.TL_username_deleteUsernameByPeer")
	proto.RegisterType((*TLUsernameSearch)(nil), "username.TL_username_search")
	proto.RegisterType((*Vector_UsernameData)(nil), "username.Vector_UsernameData")
}

func init() { proto.RegisterFile("username.tl.proto", fileDescriptor_177d8690bd27445f) }

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

func (this *UsernameData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&username.UsernameData{")
	s = append(s, "PredicateName: "+fmt.Sprintf("%#v", this.PredicateName)+",\n")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\n")
	if this.Peer != nil {
		s = append(s, "Peer: "+fmt.Sprintf("%#v", this.Peer)+",\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 *TLUsernameData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&username.TLUsernameData{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UsernameExist) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.UsernameExist{")
	s = append(s, "PredicateName: "+fmt.Sprintf("%#v", this.PredicateName)+",\n")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\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 *TLUsernameNotExisted) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&username.TLUsernameNotExisted{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLUsernameExisted) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&username.TLUsernameExisted{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLUsernameExistedNotMe) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&username.TLUsernameExistedNotMe{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLUsernameExistedIsMe) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&username.TLUsernameExistedIsMe{")
	if this.Data2 != nil {
		s = append(s, "Data2: "+fmt.Sprintf("%#v", this.Data2)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TLUsernameGetAccountUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.TLUsernameGetAccountUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\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 *TLUsernameCheckAccountUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&username.TLUsernameCheckAccountUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameGetChannelUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.TLUsernameGetChannelUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "ChannelId: "+fmt.Sprintf("%#v", this.ChannelId)+",\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 *TLUsernameCheckChannelUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&username.TLUsernameCheckChannelUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "ChannelId: "+fmt.Sprintf("%#v", this.ChannelId)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameUpdateUsernameByPeer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&username.TLUsernameUpdateUsernameByPeer{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameCheckUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.TLUsernameCheckUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameUpdateUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&username.TLUsernameUpdateUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "PeerType: "+fmt.Sprintf("%#v", this.PeerType)+",\n")
	s = append(s, "PeerId: "+fmt.Sprintf("%#v", this.PeerId)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameDeleteUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.TLUsernameDeleteUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameResolveUsername) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.TLUsernameResolveUsername{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Username: "+fmt.Sprintf("%#v", this.Username)+",\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 *TLUsernameGetListByUsernameList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&username.TLUsernameGetListByUsernameList{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Names: "+fmt.Sprintf("%#v", this.Names)+",\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 *TLUsernameDeleteUsernameByPeer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&username.TLUsernameDeleteUsernameByPeer{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\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 *TLUsernameSearch) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&username.TLUsernameSearch{")
	s = append(s, "Constructor: "+fmt.Sprintf("%#v", this.Constructor)+",\n")
	s = append(s, "Q: "+fmt.Sprintf("%#v", this.Q)+",\n")
	s = append(s, "ExcludedContacts: "+fmt.Sprintf("%#v", this.ExcludedContacts)+",\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 *Vector_UsernameData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&username.Vector_UsernameData{")
	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 valueToGoStringUsernameTl(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

// RPCUsernameClient is the client API for RPCUsername service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RPCUsernameClient interface {
	UsernameGetAccountUsername(ctx context.Context, in *TLUsernameGetAccountUsername, opts ...grpc.CallOption) (*UsernameData, error)
	UsernameCheckAccountUsername(ctx context.Context, in *TLUsernameCheckAccountUsername, opts ...grpc.CallOption) (*UsernameExist, error)
	UsernameGetChannelUsername(ctx context.Context, in *TLUsernameGetChannelUsername, opts ...grpc.CallOption) (*UsernameData, error)
	UsernameCheckChannelUsername(ctx context.Context, in *TLUsernameCheckChannelUsername, opts ...grpc.CallOption) (*UsernameExist, error)
	UsernameUpdateUsernameByPeer(ctx context.Context, in *TLUsernameUpdateUsernameByPeer, opts ...grpc.CallOption) (*mtproto.Bool, error)
	UsernameCheckUsername(ctx context.Context, in *TLUsernameCheckUsername, opts ...grpc.CallOption) (*UsernameExist, error)
	UsernameUpdateUsername(ctx context.Context, in *TLUsernameUpdateUsername, opts ...grpc.CallOption) (*mtproto.Bool, error)
	UsernameDeleteUsername(ctx context.Context, in *TLUsernameDeleteUsername, opts ...grpc.CallOption) (*mtproto.Bool, error)
	UsernameResolveUsername(ctx context.Context, in *TLUsernameResolveUsername, opts ...grpc.CallOption) (*mtproto.Peer, error)
	UsernameGetListByUsernameList(ctx context.Context, in *TLUsernameGetListByUsernameList, opts ...grpc.CallOption) (*Vector_UsernameData, error)
	UsernameDeleteUsernameByPeer(ctx context.Context, in *TLUsernameDeleteUsernameByPeer, opts ...grpc.CallOption) (*mtproto.Bool, error)
	UsernameSearch(ctx context.Context, in *TLUsernameSearch, opts ...grpc.CallOption) (*Vector_UsernameData, error)
}

type rPCUsernameClient struct {
	cc *grpc.ClientConn
}

func NewRPCUsernameClient(cc *grpc.ClientConn) RPCUsernameClient {
	return &rPCUsernameClient{cc}
}

func (c *rPCUsernameClient) UsernameGetAccountUsername(ctx context.Context, in *TLUsernameGetAccountUsername, opts ...grpc.CallOption) (*UsernameData, error) {
	out := new(UsernameData)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_getAccountUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameCheckAccountUsername(ctx context.Context, in *TLUsernameCheckAccountUsername, opts ...grpc.CallOption) (*UsernameExist, error) {
	out := new(UsernameExist)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_checkAccountUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameGetChannelUsername(ctx context.Context, in *TLUsernameGetChannelUsername, opts ...grpc.CallOption) (*UsernameData, error) {
	out := new(UsernameData)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_getChannelUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameCheckChannelUsername(ctx context.Context, in *TLUsernameCheckChannelUsername, opts ...grpc.CallOption) (*UsernameExist, error) {
	out := new(UsernameExist)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_checkChannelUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameUpdateUsernameByPeer(ctx context.Context, in *TLUsernameUpdateUsernameByPeer, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_updateUsernameByPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameCheckUsername(ctx context.Context, in *TLUsernameCheckUsername, opts ...grpc.CallOption) (*UsernameExist, error) {
	out := new(UsernameExist)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_checkUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameUpdateUsername(ctx context.Context, in *TLUsernameUpdateUsername, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_updateUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameDeleteUsername(ctx context.Context, in *TLUsernameDeleteUsername, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_deleteUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameResolveUsername(ctx context.Context, in *TLUsernameResolveUsername, opts ...grpc.CallOption) (*mtproto.Peer, error) {
	out := new(mtproto.Peer)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_resolveUsername", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameGetListByUsernameList(ctx context.Context, in *TLUsernameGetListByUsernameList, opts ...grpc.CallOption) (*Vector_UsernameData, error) {
	out := new(Vector_UsernameData)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_getListByUsernameList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameDeleteUsernameByPeer(ctx context.Context, in *TLUsernameDeleteUsernameByPeer, opts ...grpc.CallOption) (*mtproto.Bool, error) {
	out := new(mtproto.Bool)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_deleteUsernameByPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rPCUsernameClient) UsernameSearch(ctx context.Context, in *TLUsernameSearch, opts ...grpc.CallOption) (*Vector_UsernameData, error) {
	out := new(Vector_UsernameData)
	err := c.cc.Invoke(ctx, "/username.RPCUsername/username_search", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RPCUsernameServer is the server API for RPCUsername service.
type RPCUsernameServer interface {
	UsernameGetAccountUsername(context.Context, *TLUsernameGetAccountUsername) (*UsernameData, error)
	UsernameCheckAccountUsername(context.Context, *TLUsernameCheckAccountUsername) (*UsernameExist, error)
	UsernameGetChannelUsername(context.Context, *TLUsernameGetChannelUsername) (*UsernameData, error)
	UsernameCheckChannelUsername(context.Context, *TLUsernameCheckChannelUsername) (*UsernameExist, error)
	UsernameUpdateUsernameByPeer(context.Context, *TLUsernameUpdateUsernameByPeer) (*mtproto.Bool, error)
	UsernameCheckUsername(context.Context, *TLUsernameCheckUsername) (*UsernameExist, error)
	UsernameUpdateUsername(context.Context, *TLUsernameUpdateUsername) (*mtproto.Bool, error)
	UsernameDeleteUsername(context.Context, *TLUsernameDeleteUsername) (*mtproto.Bool, error)
	UsernameResolveUsername(context.Context, *TLUsernameResolveUsername) (*mtproto.Peer, error)
	UsernameGetListByUsernameList(context.Context, *TLUsernameGetListByUsernameList) (*Vector_UsernameData, error)
	UsernameDeleteUsernameByPeer(context.Context, *TLUsernameDeleteUsernameByPeer) (*mtproto.Bool, error)
	UsernameSearch(context.Context, *TLUsernameSearch) (*Vector_UsernameData, error)
}

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

func (*UnimplementedRPCUsernameServer) UsernameGetAccountUsername(ctx context.Context, req *TLUsernameGetAccountUsername) (*UsernameData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameGetAccountUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameCheckAccountUsername(ctx context.Context, req *TLUsernameCheckAccountUsername) (*UsernameExist, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameCheckAccountUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameGetChannelUsername(ctx context.Context, req *TLUsernameGetChannelUsername) (*UsernameData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameGetChannelUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameCheckChannelUsername(ctx context.Context, req *TLUsernameCheckChannelUsername) (*UsernameExist, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameCheckChannelUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameUpdateUsernameByPeer(ctx context.Context, req *TLUsernameUpdateUsernameByPeer) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameUpdateUsernameByPeer not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameCheckUsername(ctx context.Context, req *TLUsernameCheckUsername) (*UsernameExist, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameCheckUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameUpdateUsername(ctx context.Context, req *TLUsernameUpdateUsername) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameUpdateUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameDeleteUsername(ctx context.Context, req *TLUsernameDeleteUsername) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameDeleteUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameResolveUsername(ctx context.Context, req *TLUsernameResolveUsername) (*mtproto.Peer, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameResolveUsername not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameGetListByUsernameList(ctx context.Context, req *TLUsernameGetListByUsernameList) (*Vector_UsernameData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameGetListByUsernameList not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameDeleteUsernameByPeer(ctx context.Context, req *TLUsernameDeleteUsernameByPeer) (*mtproto.Bool, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameDeleteUsernameByPeer not implemented")
}
func (*UnimplementedRPCUsernameServer) UsernameSearch(ctx context.Context, req *TLUsernameSearch) (*Vector_UsernameData, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UsernameSearch not implemented")
}

func RegisterRPCUsernameServer(s *grpc.Server, srv RPCUsernameServer) {
	s.RegisterService(&_RPCUsername_serviceDesc, srv)
}

func _RPCUsername_UsernameGetAccountUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameGetAccountUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameGetAccountUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameGetAccountUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameGetAccountUsername(ctx, req.(*TLUsernameGetAccountUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameCheckAccountUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameCheckAccountUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameCheckAccountUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameCheckAccountUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameCheckAccountUsername(ctx, req.(*TLUsernameCheckAccountUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameGetChannelUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameGetChannelUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameGetChannelUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameGetChannelUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameGetChannelUsername(ctx, req.(*TLUsernameGetChannelUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameCheckChannelUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameCheckChannelUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameCheckChannelUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameCheckChannelUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameCheckChannelUsername(ctx, req.(*TLUsernameCheckChannelUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameUpdateUsernameByPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameUpdateUsernameByPeer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameUpdateUsernameByPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameUpdateUsernameByPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameUpdateUsernameByPeer(ctx, req.(*TLUsernameUpdateUsernameByPeer))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameCheckUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameCheckUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameCheckUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameCheckUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameCheckUsername(ctx, req.(*TLUsernameCheckUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameUpdateUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameUpdateUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameUpdateUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameUpdateUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameUpdateUsername(ctx, req.(*TLUsernameUpdateUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameDeleteUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameDeleteUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameDeleteUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameDeleteUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameDeleteUsername(ctx, req.(*TLUsernameDeleteUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameResolveUsername_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameResolveUsername)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameResolveUsername(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameResolveUsername",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameResolveUsername(ctx, req.(*TLUsernameResolveUsername))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameGetListByUsernameList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameGetListByUsernameList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameGetListByUsernameList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameGetListByUsernameList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameGetListByUsernameList(ctx, req.(*TLUsernameGetListByUsernameList))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameDeleteUsernameByPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameDeleteUsernameByPeer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameDeleteUsernameByPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameDeleteUsernameByPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameDeleteUsernameByPeer(ctx, req.(*TLUsernameDeleteUsernameByPeer))
	}
	return interceptor(ctx, in, info, handler)
}

func _RPCUsername_UsernameSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TLUsernameSearch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RPCUsernameServer).UsernameSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/username.RPCUsername/UsernameSearch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RPCUsernameServer).UsernameSearch(ctx, req.(*TLUsernameSearch))
	}
	return interceptor(ctx, in, info, handler)
}

var _RPCUsername_serviceDesc = grpc.ServiceDesc{
	ServiceName: "username.RPCUsername",
	HandlerType: (*RPCUsernameServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "username_getAccountUsername",
			Handler:    _RPCUsername_UsernameGetAccountUsername_Handler,
		},
		{
			MethodName: "username_checkAccountUsername",
			Handler:    _RPCUsername_UsernameCheckAccountUsername_Handler,
		},
		{
			MethodName: "username_getChannelUsername",
			Handler:    _RPCUsername_UsernameGetChannelUsername_Handler,
		},
		{
			MethodName: "username_checkChannelUsername",
			Handler:    _RPCUsername_UsernameCheckChannelUsername_Handler,
		},
		{
			MethodName: "username_updateUsernameByPeer",
			Handler:    _RPCUsername_UsernameUpdateUsernameByPeer_Handler,
		},
		{
			MethodName: "username_checkUsername",
			Handler:    _RPCUsername_UsernameCheckUsername_Handler,
		},
		{
			MethodName: "username_updateUsername",
			Handler:    _RPCUsername_UsernameUpdateUsername_Handler,
		},
		{
			MethodName: "username_deleteUsername",
			Handler:    _RPCUsername_UsernameDeleteUsername_Handler,
		},
		{
			MethodName: "username_resolveUsername",
			Handler:    _RPCUsername_UsernameResolveUsername_Handler,
		},
		{
			MethodName: "username_getListByUsernameList",
			Handler:    _RPCUsername_UsernameGetListByUsernameList_Handler,
		},
		{
			MethodName: "username_deleteUsernameByPeer",
			Handler:    _RPCUsername_UsernameDeleteUsernameByPeer_Handler,
		},
		{
			MethodName: "username_search",
			Handler:    _RPCUsername_UsernameSearch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "username.tl.proto",
}

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

func (m *UsernameData) 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.Peer != nil {
		{
			size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUsernameTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PredicateName) > 0 {
		i -= len(m.PredicateName)
		copy(dAtA[i:], m.PredicateName)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.PredicateName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUsernameTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UsernameExist) 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.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PredicateName) > 0 {
		i -= len(m.PredicateName)
		copy(dAtA[i:], m.PredicateName)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.PredicateName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameNotExisted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUsernameTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameExisted) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUsernameTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameExistedNotMe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUsernameTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameExistedIsMe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Data2 != nil {
		{
			size, err := m.Data2.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintUsernameTl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TLUsernameCheckAccountUsername) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x22
	}
	if m.UserId != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.UserId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TLUsernameCheckChannelUsername) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x22
	}
	if m.ChannelId != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.ChannelId))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameUpdateUsernameByPeer) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x2a
	}
	if m.PeerId != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x20
	}
	if m.PeerType != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameCheckUsername) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameUpdateUsername) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x2a
	}
	if m.PeerId != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.PeerId))
		i--
		dAtA[i] = 0x20
	}
	if m.PeerType != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.PeerType))
		i--
		dAtA[i] = 0x18
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameDeleteUsername) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameResolveUsername) 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.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TLUsernameGetListByUsernameList) 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.Names) > 0 {
		for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Names[iNdEx])
			copy(dAtA[i:], m.Names[iNdEx])
			i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Names[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TLUsernameSearch) 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 = encodeVarintUsernameTl(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ExcludedContacts) > 0 {
		dAtA8 := make([]byte, len(m.ExcludedContacts)*10)
		var j7 int
		for _, num1 := range m.ExcludedContacts {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintUsernameTl(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Q) > 0 {
		i -= len(m.Q)
		copy(dAtA[i:], m.Q)
		i = encodeVarintUsernameTl(dAtA, i, uint64(len(m.Q)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Constructor != 0 {
		i = encodeVarintUsernameTl(dAtA, i, uint64(m.Constructor))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Vector_UsernameData) 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 = encodeVarintUsernameTl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

func (m *TLUsernameCheckAccountUsername) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	if m.UserId != 0 {
		n += 1 + sovUsernameTl(uint64(m.UserId))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovUsernameTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLUsernameGetChannelUsername) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	if m.ChannelId != 0 {
		n += 1 + sovUsernameTl(uint64(m.ChannelId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLUsernameCheckChannelUsername) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	if m.ChannelId != 0 {
		n += 1 + sovUsernameTl(uint64(m.ChannelId))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovUsernameTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *TLUsernameCheckUsername) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovUsernameTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *TLUsernameDeleteUsername) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovUsernameTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLUsernameResolveUsername) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovUsernameTl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TLUsernameGetListByUsernameList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	if len(m.Names) > 0 {
		for _, s := range m.Names {
			l = len(s)
			n += 1 + l + sovUsernameTl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *TLUsernameSearch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constructor != 0 {
		n += 1 + sovUsernameTl(uint64(m.Constructor))
	}
	l = len(m.Q)
	if l > 0 {
		n += 1 + l + sovUsernameTl(uint64(l))
	}
	if len(m.ExcludedContacts) > 0 {
		l = 0
		for _, e := range m.ExcludedContacts {
			l += sovUsernameTl(uint64(e))
		}
		n += 1 + sovUsernameTl(uint64(l)) + l
	}
	if m.Limit != 0 {
		n += 1 + sovUsernameTl(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Vector_UsernameData) 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 + sovUsernameTl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovUsernameTl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozUsernameTl(x uint64) (n int) {
	return sovUsernameTl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *UsernameData) 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 ErrIntOverflowUsernameTl
			}
			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: UsernameData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UsernameData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PredicateName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PredicateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Peer == nil {
				m.Peer = &mtproto.Peer{}
			}
			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameData) 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 ErrIntOverflowUsernameTl
			}
			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_usernameData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_usernameData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &UsernameData{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *UsernameExist) 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 ErrIntOverflowUsernameTl
			}
			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: UsernameExist: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UsernameExist: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PredicateName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PredicateName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constructor", wireType)
			}
			m.Constructor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameNotExisted) 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 ErrIntOverflowUsernameTl
			}
			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_usernameNotExisted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_usernameNotExisted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &UsernameExist{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameExisted) 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 ErrIntOverflowUsernameTl
			}
			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_usernameExisted: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_usernameExisted: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &UsernameExist{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameExistedNotMe) 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 ErrIntOverflowUsernameTl
			}
			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_usernameExistedNotMe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_usernameExistedNotMe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &UsernameExist{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameExistedIsMe) 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 ErrIntOverflowUsernameTl
			}
			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_usernameExistedIsMe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_usernameExistedIsMe: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data2 == nil {
				m.Data2 = &UsernameExist{}
			}
			if err := m.Data2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameGetAccountUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_getAccountUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_getAccountUsername: 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 ErrIntOverflowUsernameTl
				}
				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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameCheckAccountUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_checkAccountUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_checkAccountUsername: 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 ErrIntOverflowUsernameTl
				}
				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 ErrIntOverflowUsernameTl
				}
				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 Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameGetChannelUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_getChannelUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_getChannelUsername: 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 ErrIntOverflowUsernameTl
				}
				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 ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameCheckChannelUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_checkChannelUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_checkChannelUsername: 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 ErrIntOverflowUsernameTl
				}
				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 ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameUpdateUsernameByPeer) 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 ErrIntOverflowUsernameTl
			}
			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_username_updateUsernameByPeer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_updateUsernameByPeer: 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 ErrIntOverflowUsernameTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameCheckUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_checkUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_checkUsername: 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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameUpdateUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_updateUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_updateUsername: 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 ErrIntOverflowUsernameTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameDeleteUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_deleteUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_deleteUsername: 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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameResolveUsername) 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 ErrIntOverflowUsernameTl
			}
			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_username_resolveUsername: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_resolveUsername: 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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameGetListByUsernameList) 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 ErrIntOverflowUsernameTl
			}
			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_username_getListByUsernameList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_getListByUsernameList: 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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Names = append(m.Names, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameDeleteUsernameByPeer) 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 ErrIntOverflowUsernameTl
			}
			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_username_deleteUsernameByPeer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_deleteUsernameByPeer: 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 ErrIntOverflowUsernameTl
				}
				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 PeerType", wireType)
			}
			m.PeerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PeerType |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowUsernameTl
				}
				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 := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 *TLUsernameSearch) 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 ErrIntOverflowUsernameTl
			}
			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_username_search: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TL_username_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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Constructor |= TLConstructor(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Q", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Q = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUsernameTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ExcludedContacts = append(m.ExcludedContacts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowUsernameTl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthUsernameTl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthUsernameTl
				}
				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.ExcludedContacts) == 0 {
					m.ExcludedContacts = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowUsernameTl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ExcludedContacts = append(m.ExcludedContacts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ExcludedContacts", wireType)
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowUsernameTl
				}
				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 := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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_UsernameData) 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 ErrIntOverflowUsernameTl
			}
			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_UsernameData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vector_UsernameData: 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 ErrIntOverflowUsernameTl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthUsernameTl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthUsernameTl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Datas = append(m.Datas, &UsernameData{})
			if err := m.Datas[len(m.Datas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipUsernameTl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthUsernameTl
			}
			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 skipUsernameTl(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, ErrIntOverflowUsernameTl
			}
			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, ErrIntOverflowUsernameTl
				}
				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, ErrIntOverflowUsernameTl
				}
				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, ErrInvalidLengthUsernameTl
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupUsernameTl
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthUsernameTl
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthUsernameTl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowUsernameTl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupUsernameTl = fmt.Errorf("proto: unexpected end of group")
)