msgs.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: desmos/profiles/v1beta1/msgs.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	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"
)

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

// MsgSaveProfile represents a message to save a profile.
type MsgSaveProfile struct {
	Dtag           string `protobuf:"bytes,1,opt,name=dtag,proto3" json:"dtag,omitempty" yaml:"dtag"`
	Moniker        string `protobuf:"bytes,2,opt,name=moniker,proto3" json:"moniker,omitempty" yaml:"moniker"`
	Bio            string `protobuf:"bytes,3,opt,name=bio,proto3" json:"bio,omitempty" yaml:"bio"`
	ProfilePicture string `protobuf:"bytes,4,opt,name=profile_picture,json=profilePicture,proto3" json:"profile_picture" yaml:"profile_picture"`
	CoverPicture   string `protobuf:"bytes,5,opt,name=cover_picture,json=coverPicture,proto3" json:"cover_picture" yaml:"cover_picture"`
	Creator        string `protobuf:"bytes,6,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
}

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

var xxx_messageInfo_MsgSaveProfile proto.InternalMessageInfo

// MsgSaveProfileResponse defines the Msg/SaveProfile response type.
type MsgSaveProfileResponse struct {
}

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

var xxx_messageInfo_MsgSaveProfileResponse proto.InternalMessageInfo

// MsgDeleteProfile represents the message used to delete an existing profile.
type MsgDeleteProfile struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
}

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

var xxx_messageInfo_MsgDeleteProfile proto.InternalMessageInfo

// MsgDeleteProfileResponse defines the Msg/DeleteProfile response type.
type MsgDeleteProfileResponse struct {
}

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

var xxx_messageInfo_MsgDeleteProfileResponse proto.InternalMessageInfo

// MsgRequestDTagTransfer represents the message used to request the DTag
// transfer to another user.
type MsgRequestDTagTransfer struct {
	Receiver string `protobuf:"bytes,1,opt,name=receiver,proto3" json:"receiver,omitempty" yaml:"receiver"`
	Sender   string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
}

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

var xxx_messageInfo_MsgRequestDTagTransfer proto.InternalMessageInfo

// MsgRequestDTagTransferResponse defines the Msg/RequestDTagTransfer response
// type.
type MsgRequestDTagTransferResponse struct {
}

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

var xxx_messageInfo_MsgRequestDTagTransferResponse proto.InternalMessageInfo

// MsgCancelDTagTransfer represents the message used to cancel a DTag transfer
// request.
type MsgCancelDTagTransfer struct {
	Receiver string `protobuf:"bytes,1,opt,name=receiver,proto3" json:"receiver,omitempty" yaml:"receiver"`
	Sender   string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
}

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

var xxx_messageInfo_MsgCancelDTagTransfer proto.InternalMessageInfo

// MsgCancelDTagTransferResponse represents the Msg/CancelDTagTransfer response
// type.
type MsgCancelDTagTransferResponse struct {
}

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

var xxx_messageInfo_MsgCancelDTagTransferResponse proto.InternalMessageInfo

// MsgAcceptDTagTransfer represents the message used to accept a DTag transfer
// request.
type MsgAcceptDTagTransfer struct {
	NewDtag  string `protobuf:"bytes,1,opt,name=new_dtag,json=newDtag,proto3" json:"new_dtag" yaml:"new_dtag"`
	Sender   string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	Receiver string `protobuf:"bytes,3,opt,name=receiver,proto3" json:"receiver,omitempty" yaml:"receiver"`
}

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

var xxx_messageInfo_MsgAcceptDTagTransfer proto.InternalMessageInfo

// MsgAcceptDTagTransferResponse defines the Msg/AcceptDTagTransfer response.
type MsgAcceptDTagTransferResponse struct {
}

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

var xxx_messageInfo_MsgAcceptDTagTransferResponse proto.InternalMessageInfo

// MsgRefuseDTagTransfer represents the message used to refuse a DTag transfer
// request.
type MsgRefuseDTagTransfer struct {
	Sender   string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
	Receiver string `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty" yaml:"receiver"`
}

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

var xxx_messageInfo_MsgRefuseDTagTransfer proto.InternalMessageInfo

// MsgRefuseDTagTransferResponse defines the Msg/RefuseDTagTransfer response.
type MsgRefuseDTagTransferResponse struct {
}

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

var xxx_messageInfo_MsgRefuseDTagTransferResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgSaveProfile)(nil), "desmos.profiles.v1beta1.MsgSaveProfile")
	proto.RegisterType((*MsgSaveProfileResponse)(nil), "desmos.profiles.v1beta1.MsgSaveProfileResponse")
	proto.RegisterType((*MsgDeleteProfile)(nil), "desmos.profiles.v1beta1.MsgDeleteProfile")
	proto.RegisterType((*MsgDeleteProfileResponse)(nil), "desmos.profiles.v1beta1.MsgDeleteProfileResponse")
	proto.RegisterType((*MsgRequestDTagTransfer)(nil), "desmos.profiles.v1beta1.MsgRequestDTagTransfer")
	proto.RegisterType((*MsgRequestDTagTransferResponse)(nil), "desmos.profiles.v1beta1.MsgRequestDTagTransferResponse")
	proto.RegisterType((*MsgCancelDTagTransfer)(nil), "desmos.profiles.v1beta1.MsgCancelDTagTransfer")
	proto.RegisterType((*MsgCancelDTagTransferResponse)(nil), "desmos.profiles.v1beta1.MsgCancelDTagTransferResponse")
	proto.RegisterType((*MsgAcceptDTagTransfer)(nil), "desmos.profiles.v1beta1.MsgAcceptDTagTransfer")
	proto.RegisterType((*MsgAcceptDTagTransferResponse)(nil), "desmos.profiles.v1beta1.MsgAcceptDTagTransferResponse")
	proto.RegisterType((*MsgRefuseDTagTransfer)(nil), "desmos.profiles.v1beta1.MsgRefuseDTagTransfer")
	proto.RegisterType((*MsgRefuseDTagTransferResponse)(nil), "desmos.profiles.v1beta1.MsgRefuseDTagTransferResponse")
}

func init() {
	proto.RegisterFile("desmos/profiles/v1beta1/msgs.proto", fileDescriptor_94c87963fc3f5529)
}

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

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

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// SaveProfile defines the method to save a profile
	SaveProfile(ctx context.Context, in *MsgSaveProfile, opts ...grpc.CallOption) (*MsgSaveProfileResponse, error)
	// DeleteProfile defines the method to delete an existing profile
	DeleteProfile(ctx context.Context, in *MsgDeleteProfile, opts ...grpc.CallOption) (*MsgDeleteProfileResponse, error)
	// RequestDTagTransfer defines the method to request another user to transfer
	// their DTag to you
	RequestDTagTransfer(ctx context.Context, in *MsgRequestDTagTransfer, opts ...grpc.CallOption) (*MsgRequestDTagTransferResponse, error)
	// CancelDTagTransfer defines the method to cancel an outgoing DTag transfer
	// request
	CancelDTagTransfer(ctx context.Context, in *MsgCancelDTagTransfer, opts ...grpc.CallOption) (*MsgCancelDTagTransferResponse, error)
	// AcceptDTagTransfer defines the method to accept an incoming DTag transfer
	// request
	AcceptDTagTransfer(ctx context.Context, in *MsgAcceptDTagTransfer, opts ...grpc.CallOption) (*MsgAcceptDTagTransferResponse, error)
	// RefuseDTagTransfer defines the method to refuse an incoming DTag transfer
	// request
	RefuseDTagTransfer(ctx context.Context, in *MsgRefuseDTagTransfer, opts ...grpc.CallOption) (*MsgRefuseDTagTransferResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) SaveProfile(ctx context.Context, in *MsgSaveProfile, opts ...grpc.CallOption) (*MsgSaveProfileResponse, error) {
	out := new(MsgSaveProfileResponse)
	err := c.cc.Invoke(ctx, "/desmos.profiles.v1beta1.Msg/SaveProfile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DeleteProfile(ctx context.Context, in *MsgDeleteProfile, opts ...grpc.CallOption) (*MsgDeleteProfileResponse, error) {
	out := new(MsgDeleteProfileResponse)
	err := c.cc.Invoke(ctx, "/desmos.profiles.v1beta1.Msg/DeleteProfile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RequestDTagTransfer(ctx context.Context, in *MsgRequestDTagTransfer, opts ...grpc.CallOption) (*MsgRequestDTagTransferResponse, error) {
	out := new(MsgRequestDTagTransferResponse)
	err := c.cc.Invoke(ctx, "/desmos.profiles.v1beta1.Msg/RequestDTagTransfer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CancelDTagTransfer(ctx context.Context, in *MsgCancelDTagTransfer, opts ...grpc.CallOption) (*MsgCancelDTagTransferResponse, error) {
	out := new(MsgCancelDTagTransferResponse)
	err := c.cc.Invoke(ctx, "/desmos.profiles.v1beta1.Msg/CancelDTagTransfer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AcceptDTagTransfer(ctx context.Context, in *MsgAcceptDTagTransfer, opts ...grpc.CallOption) (*MsgAcceptDTagTransferResponse, error) {
	out := new(MsgAcceptDTagTransferResponse)
	err := c.cc.Invoke(ctx, "/desmos.profiles.v1beta1.Msg/AcceptDTagTransfer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RefuseDTagTransfer(ctx context.Context, in *MsgRefuseDTagTransfer, opts ...grpc.CallOption) (*MsgRefuseDTagTransferResponse, error) {
	out := new(MsgRefuseDTagTransferResponse)
	err := c.cc.Invoke(ctx, "/desmos.profiles.v1beta1.Msg/RefuseDTagTransfer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// SaveProfile defines the method to save a profile
	SaveProfile(context.Context, *MsgSaveProfile) (*MsgSaveProfileResponse, error)
	// DeleteProfile defines the method to delete an existing profile
	DeleteProfile(context.Context, *MsgDeleteProfile) (*MsgDeleteProfileResponse, error)
	// RequestDTagTransfer defines the method to request another user to transfer
	// their DTag to you
	RequestDTagTransfer(context.Context, *MsgRequestDTagTransfer) (*MsgRequestDTagTransferResponse, error)
	// CancelDTagTransfer defines the method to cancel an outgoing DTag transfer
	// request
	CancelDTagTransfer(context.Context, *MsgCancelDTagTransfer) (*MsgCancelDTagTransferResponse, error)
	// AcceptDTagTransfer defines the method to accept an incoming DTag transfer
	// request
	AcceptDTagTransfer(context.Context, *MsgAcceptDTagTransfer) (*MsgAcceptDTagTransferResponse, error)
	// RefuseDTagTransfer defines the method to refuse an incoming DTag transfer
	// request
	RefuseDTagTransfer(context.Context, *MsgRefuseDTagTransfer) (*MsgRefuseDTagTransferResponse, error)
}

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

func (*UnimplementedMsgServer) SaveProfile(ctx context.Context, req *MsgSaveProfile) (*MsgSaveProfileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SaveProfile not implemented")
}
func (*UnimplementedMsgServer) DeleteProfile(ctx context.Context, req *MsgDeleteProfile) (*MsgDeleteProfileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteProfile not implemented")
}
func (*UnimplementedMsgServer) RequestDTagTransfer(ctx context.Context, req *MsgRequestDTagTransfer) (*MsgRequestDTagTransferResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestDTagTransfer not implemented")
}
func (*UnimplementedMsgServer) CancelDTagTransfer(ctx context.Context, req *MsgCancelDTagTransfer) (*MsgCancelDTagTransferResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelDTagTransfer not implemented")
}
func (*UnimplementedMsgServer) AcceptDTagTransfer(ctx context.Context, req *MsgAcceptDTagTransfer) (*MsgAcceptDTagTransferResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AcceptDTagTransfer not implemented")
}
func (*UnimplementedMsgServer) RefuseDTagTransfer(ctx context.Context, req *MsgRefuseDTagTransfer) (*MsgRefuseDTagTransferResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RefuseDTagTransfer not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_SaveProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSaveProfile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SaveProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.profiles.v1beta1.Msg/SaveProfile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SaveProfile(ctx, req.(*MsgSaveProfile))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DeleteProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeleteProfile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DeleteProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.profiles.v1beta1.Msg/DeleteProfile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DeleteProfile(ctx, req.(*MsgDeleteProfile))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RequestDTagTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRequestDTagTransfer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RequestDTagTransfer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.profiles.v1beta1.Msg/RequestDTagTransfer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RequestDTagTransfer(ctx, req.(*MsgRequestDTagTransfer))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CancelDTagTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCancelDTagTransfer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CancelDTagTransfer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.profiles.v1beta1.Msg/CancelDTagTransfer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CancelDTagTransfer(ctx, req.(*MsgCancelDTagTransfer))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AcceptDTagTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAcceptDTagTransfer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AcceptDTagTransfer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.profiles.v1beta1.Msg/AcceptDTagTransfer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AcceptDTagTransfer(ctx, req.(*MsgAcceptDTagTransfer))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RefuseDTagTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRefuseDTagTransfer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RefuseDTagTransfer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/desmos.profiles.v1beta1.Msg/RefuseDTagTransfer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RefuseDTagTransfer(ctx, req.(*MsgRefuseDTagTransfer))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "desmos.profiles.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SaveProfile",
			Handler:    _Msg_SaveProfile_Handler,
		},
		{
			MethodName: "DeleteProfile",
			Handler:    _Msg_DeleteProfile_Handler,
		},
		{
			MethodName: "RequestDTagTransfer",
			Handler:    _Msg_RequestDTagTransfer_Handler,
		},
		{
			MethodName: "CancelDTagTransfer",
			Handler:    _Msg_CancelDTagTransfer_Handler,
		},
		{
			MethodName: "AcceptDTagTransfer",
			Handler:    _Msg_AcceptDTagTransfer_Handler,
		},
		{
			MethodName: "RefuseDTagTransfer",
			Handler:    _Msg_RefuseDTagTransfer_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "desmos/profiles/v1beta1/msgs.proto",
}

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

func (m *MsgSaveProfile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.CoverPicture) > 0 {
		i -= len(m.CoverPicture)
		copy(dAtA[i:], m.CoverPicture)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.CoverPicture)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ProfilePicture) > 0 {
		i -= len(m.ProfilePicture)
		copy(dAtA[i:], m.ProfilePicture)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.ProfilePicture)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Bio) > 0 {
		i -= len(m.Bio)
		copy(dAtA[i:], m.Bio)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Bio)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Moniker) > 0 {
		i -= len(m.Moniker)
		copy(dAtA[i:], m.Moniker)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Moniker)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Dtag) > 0 {
		i -= len(m.Dtag)
		copy(dAtA[i:], m.Dtag)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Dtag)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgSaveProfileResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *MsgDeleteProfile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgDeleteProfileResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *MsgRequestDTagTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgRequestDTagTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *MsgCancelDTagTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgCancelDTagTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *MsgAcceptDTagTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NewDtag) > 0 {
		i -= len(m.NewDtag)
		copy(dAtA[i:], m.NewDtag)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.NewDtag)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgAcceptDTagTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *MsgRefuseDTagTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgRefuseDTagTransferResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintMsgs(dAtA []byte, offset int, v uint64) int {
	offset -= sovMsgs(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgSaveProfile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Dtag)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Moniker)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Bio)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.ProfilePicture)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.CoverPicture)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgSaveProfileResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDeleteProfile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgDeleteProfileResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgRequestDTagTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgRequestDTagTransferResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgCancelDTagTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgCancelDTagTransferResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgAcceptDTagTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NewDtag)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgAcceptDTagTransferResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgRefuseDTagTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgRefuseDTagTransferResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovMsgs(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMsgs(x uint64) (n int) {
	return sovMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgSaveProfile) 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 ErrIntOverflowMsgs
			}
			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: MsgSaveProfile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSaveProfile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dtag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dtag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Moniker = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bio = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfilePicture", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfilePicture = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoverPicture", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CoverPicture = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSaveProfileResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgSaveProfileResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSaveProfileResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDeleteProfile) 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 ErrIntOverflowMsgs
			}
			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: MsgDeleteProfile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteProfile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDeleteProfileResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgDeleteProfileResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteProfileResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRequestDTagTransfer) 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 ErrIntOverflowMsgs
			}
			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: MsgRequestDTagTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRequestDTagTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRequestDTagTransferResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgRequestDTagTransferResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRequestDTagTransferResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCancelDTagTransfer) 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 ErrIntOverflowMsgs
			}
			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: MsgCancelDTagTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCancelDTagTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCancelDTagTransferResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgCancelDTagTransferResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCancelDTagTransferResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAcceptDTagTransfer) 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 ErrIntOverflowMsgs
			}
			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: MsgAcceptDTagTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAcceptDTagTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewDtag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewDtag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAcceptDTagTransferResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgAcceptDTagTransferResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAcceptDTagTransferResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRefuseDTagTransfer) 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 ErrIntOverflowMsgs
			}
			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: MsgRefuseDTagTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRefuseDTagTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				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 ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receiver = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRefuseDTagTransferResponse) 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 ErrIntOverflowMsgs
			}
			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: MsgRefuseDTagTransferResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRefuseDTagTransferResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthMsgs        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMsgs          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMsgs = fmt.Errorf("proto: unexpected end of group")
)