msgs.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: desmos/posts/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

// MsgCreatePost represents the message to be used to create a post.
type MsgCreatePost struct {
	ParentID             string        `protobuf:"bytes,1,opt,name=parent_id,json=parentId,proto3" json:"parent_id" yaml:"parent_id"`
	Message              string        `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty" yaml:"message"`
	CommentsState        CommentsState `protobuf:"varint,3,opt,name=comments_state,json=commentsState,proto3,enum=desmos.posts.v1beta1.CommentsState" json:"comments_state" yaml:"comments_state"`
	Subspace             string        `protobuf:"bytes,4,opt,name=subspace,proto3" json:"subspace,omitempty" yaml:"subspace"`
	AdditionalAttributes []Attribute   `protobuf:"bytes,5,rep,name=additional_attributes,json=additionalAttributes,proto3" json:"additional_attributes,omitempty" yaml:"additional_attributes,omitempty"`
	Creator              string        `protobuf:"bytes,6,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
	Attachments          []Attachment  `protobuf:"bytes,7,rep,name=attachments,proto3" json:"attachments,omitempty" yaml:"attachments,omitempty"`
	Poll                 *Poll         `protobuf:"bytes,8,opt,name=poll,proto3" json:"poll,omitempty" yaml:"poll,omitempty"`
}

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

var xxx_messageInfo_MsgCreatePost proto.InternalMessageInfo

// MsgCreatePostResponse defines the Msg/CreatePost response type.
type MsgCreatePostResponse struct {
}

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

var xxx_messageInfo_MsgCreatePostResponse proto.InternalMessageInfo

// MsgEditPost represents the message used to edit a post.
type MsgEditPost struct {
	PostID        string        `protobuf:"bytes,1,opt,name=post_id,json=postId,proto3" json:"post_id" yaml:"post_id"`
	Message       string        `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty" yaml:"message"`
	CommentsState CommentsState `protobuf:"varint,3,opt,name=comments_state,json=commentsState,proto3,enum=desmos.posts.v1beta1.CommentsState" json:"comments_state" yaml:"comments_state"`
	Attachments   []Attachment  `protobuf:"bytes,4,rep,name=attachments,proto3" json:"attachments,omitempty" yaml:"attachments,omitempty"`
	Poll          *Poll         `protobuf:"bytes,5,opt,name=poll,proto3" json:"poll,omitempty" yaml:"poll,omitempty"`
	Editor        string        `protobuf:"bytes,6,opt,name=editor,proto3" json:"editor,omitempty" yaml:"editor"`
}

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

var xxx_messageInfo_MsgEditPost proto.InternalMessageInfo

// MsgEditPostResponse defines the Msg/EditPost response type.
type MsgEditPostResponse struct {
}

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

var xxx_messageInfo_MsgEditPostResponse proto.InternalMessageInfo

// MsgAddPostReaction represents the message to be used to add a reaction to a
// post
type MsgAddPostReaction struct {
	PostID   string `protobuf:"bytes,1,opt,name=post_id,json=postId,proto3" json:"post_id" yaml:"post_id"`
	Reaction string `protobuf:"bytes,2,opt,name=reaction,proto3" json:"reaction,omitempty" yaml:"reaction"`
	User     string `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

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

var xxx_messageInfo_MsgAddPostReaction proto.InternalMessageInfo

// MsgAddPostReactionResponse defines the Msg/AddReaction response type.
type MsgAddPostReactionResponse struct {
}

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

var xxx_messageInfo_MsgAddPostReactionResponse proto.InternalMessageInfo

// MsgRemovePostReaction represents the message to be used when wanting to
// remove an existing reaction from a specific user having a specific value
type MsgRemovePostReaction struct {
	PostID   string `protobuf:"bytes,1,opt,name=post_id,json=postId,proto3" json:"post_id" yaml:"post_id"`
	Reaction string `protobuf:"bytes,2,opt,name=reaction,proto3" json:"reaction,omitempty" yaml:"reaction"`
	User     string `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

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

var xxx_messageInfo_MsgRemovePostReaction proto.InternalMessageInfo

// MsgRemovePostReactionResponse defines the Msg/RemovePostReaction response
// type.
type MsgRemovePostReactionResponse struct {
}

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

var xxx_messageInfo_MsgRemovePostReactionResponse proto.InternalMessageInfo

// MsgAnswerPoll represents the message to be used when wanting to answer a poll
type MsgAnswerPoll struct {
	PostID   string   `protobuf:"bytes,1,opt,name=post_id,json=postId,proto3" json:"post_id" yaml:"post_id"`
	Answers  []string `protobuf:"bytes,2,rep,name=answers,proto3" json:"answers" yaml:"answers"`
	Answerer string   `protobuf:"bytes,3,opt,name=answerer,proto3" json:"answerer,omitempty" yaml:"answerer"`
}

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

var xxx_messageInfo_MsgAnswerPoll proto.InternalMessageInfo

// MsgAnswerPollResponse defines the Msg/AnswerPoll response type.
type MsgAnswerPollResponse struct {
}

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

var xxx_messageInfo_MsgAnswerPollResponse proto.InternalMessageInfo

// MsgRegisterReaction represents the message that must be used when wanting
// to register a new reaction shortCode and the associated value
type MsgRegisterReaction struct {
	ShortCode string `protobuf:"bytes,1,opt,name=short_code,json=shortCode,proto3" json:"short_code" yaml:"short_code"`
	Value     string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty" yaml:"value"`
	Subspace  string `protobuf:"bytes,3,opt,name=subspace,proto3" json:"subspace,omitempty" yaml:"subspace"`
	Creator   string `protobuf:"bytes,4,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
}

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

var xxx_messageInfo_MsgRegisterReaction proto.InternalMessageInfo

// MsgRegisterReactionResponse defines the Msg/RegisterReaction response type.
type MsgRegisterReactionResponse struct {
}

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

var xxx_messageInfo_MsgRegisterReactionResponse proto.InternalMessageInfo

// MsgReportPost represents a message to create a port report.
type MsgReportPost struct {
	PostID     string `protobuf:"bytes,1,opt,name=post_id,json=postId,proto3" json:"post_id" yaml:"post_id"`
	ReportType string `protobuf:"bytes,2,opt,name=report_type,json=reportType,proto3" json:"report_type,omitempty" yaml:"type"`
	Message    string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty" yaml:"message"`
	User       string `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty" yaml:"user"`
}

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

var xxx_messageInfo_MsgReportPost proto.InternalMessageInfo

// MsgReportPostResponse defines the Msg/ReportPost response type.
type MsgReportPostResponse struct {
}

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

var xxx_messageInfo_MsgReportPostResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreatePost)(nil), "desmos.posts.v1beta1.MsgCreatePost")
	proto.RegisterType((*MsgCreatePostResponse)(nil), "desmos.posts.v1beta1.MsgCreatePostResponse")
	proto.RegisterType((*MsgEditPost)(nil), "desmos.posts.v1beta1.MsgEditPost")
	proto.RegisterType((*MsgEditPostResponse)(nil), "desmos.posts.v1beta1.MsgEditPostResponse")
	proto.RegisterType((*MsgAddPostReaction)(nil), "desmos.posts.v1beta1.MsgAddPostReaction")
	proto.RegisterType((*MsgAddPostReactionResponse)(nil), "desmos.posts.v1beta1.MsgAddPostReactionResponse")
	proto.RegisterType((*MsgRemovePostReaction)(nil), "desmos.posts.v1beta1.MsgRemovePostReaction")
	proto.RegisterType((*MsgRemovePostReactionResponse)(nil), "desmos.posts.v1beta1.MsgRemovePostReactionResponse")
	proto.RegisterType((*MsgAnswerPoll)(nil), "desmos.posts.v1beta1.MsgAnswerPoll")
	proto.RegisterType((*MsgAnswerPollResponse)(nil), "desmos.posts.v1beta1.MsgAnswerPollResponse")
	proto.RegisterType((*MsgRegisterReaction)(nil), "desmos.posts.v1beta1.MsgRegisterReaction")
	proto.RegisterType((*MsgRegisterReactionResponse)(nil), "desmos.posts.v1beta1.MsgRegisterReactionResponse")
	proto.RegisterType((*MsgReportPost)(nil), "desmos.posts.v1beta1.MsgReportPost")
	proto.RegisterType((*MsgReportPostResponse)(nil), "desmos.posts.v1beta1.MsgReportPostResponse")
}

func init() { proto.RegisterFile("desmos/posts/v1beta1/msgs.proto", fileDescriptor_12fe981997856c11) }

var fileDescriptor_12fe981997856c11 = []byte{
	// 1016 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x57, 0xcd, 0x6b, 0x1b, 0x47,
	0x14, 0xd7, 0x46, 0x1f, 0x96, 0x46, 0xf5, 0x47, 0x36, 0x16, 0x11, 0x6a, 0xac, 0x51, 0xc7, 0x90,
	0xca, 0x24, 0xd1, 0xc6, 0x0a, 0xb4, 0x10, 0x28, 0xd4, 0x72, 0x7b, 0x48, 0xc1, 0xe0, 0x4e, 0x7b,
	0x28, 0x2d, 0x44, 0xac, 0xb4, 0xc3, 0x7a, 0x41, 0xab, 0x59, 0x76, 0x46, 0x4a, 0x7d, 0xec, 0xad,
	0x87, 0x1e, 0xfa, 0x27, 0xe4, 0xd6, 0xff, 0xa0, 0xd0, 0x3f, 0xa0, 0x90, 0x63, 0x8e, 0x39, 0x2d,
	0x41, 0xbe, 0x14, 0x1d, 0x75, 0xe8, 0xb9, 0xec, 0xcc, 0xec, 0x6a, 0xf5, 0x69, 0x15, 0x5c, 0x8a,
	0x6f, 0xeb, 0xf7, 0x7e, 0xef, 0xbd, 0xf9, 0xbd, 0x4f, 0x0b, 0x40, 0x8b, 0x30, 0x97, 0x32, 0xc3,
	0xa3, 0x8c, 0x33, 0x63, 0x78, 0xdc, 0x21, 0xdc, 0x3c, 0x36, 0x5c, 0x66, 0xb3, 0x86, 0xe7, 0x53,
	0x4e, 0xf5, 0x7d, 0x09, 0x68, 0x08, 0x40, 0x43, 0x01, 0x2a, 0xfb, 0x36, 0xb5, 0xa9, 0x00, 0x18,
	0xe1, 0x97, 0xc4, 0x56, 0x6a, 0x4b, 0x9d, 0x49, 0xcb, 0xf5, 0x88, 0x5e, 0x4f, 0x21, 0xd0, 0xdf,
	0x59, 0xb0, 0x7d, 0xc6, 0xec, 0x53, 0x9f, 0x98, 0x9c, 0x9c, 0x53, 0xc6, 0xf5, 0xaf, 0x40, 0xc1,
	0x33, 0x7d, 0xd2, 0xe7, 0x6d, 0xc7, 0x2a, 0x6b, 0x35, 0xad, 0x5e, 0x68, 0x3d, 0x19, 0x05, 0x30,
	0x7f, 0x2e, 0x84, 0x2f, 0xbe, 0x18, 0x07, 0x70, 0x0a, 0x98, 0x04, 0x70, 0xef, 0xd2, 0x74, 0x7b,
	0xcf, 0x51, 0x2c, 0x42, 0x38, 0x2f, 0xbf, 0x5f, 0x58, 0xfa, 0x63, 0xb0, 0xe5, 0x12, 0xc6, 0x4c,
	0x9b, 0x94, 0xef, 0x08, 0x4f, 0xfa, 0x24, 0x80, 0x3b, 0xd2, 0x40, 0x29, 0x10, 0x8e, 0x20, 0xfa,
	0x2b, 0xb0, 0xd3, 0xa5, 0xae, 0x4b, 0xfa, 0x9c, 0xb5, 0x19, 0x37, 0x39, 0x29, 0xa7, 0x6b, 0x5a,
	0x7d, 0xa7, 0x79, 0xd8, 0x58, 0x96, 0x94, 0xc6, 0xa9, 0xc2, 0x7e, 0x13, 0x42, 0x5b, 0x8f, 0xc6,
	0x01, 0x9c, 0x33, 0x9f, 0x04, 0xb0, 0x24, 0x63, 0xcd, 0xca, 0x11, 0xde, 0xee, 0x26, 0x6d, 0x75,
	0x03, 0xe4, 0xd9, 0xa0, 0xc3, 0x3c, 0xb3, 0x4b, 0xca, 0x19, 0xf1, 0xce, 0x7b, 0x93, 0x00, 0xee,
	0x4a, 0xdb, 0x48, 0x83, 0x70, 0x0c, 0xd2, 0x7f, 0xd3, 0x40, 0xc9, 0xb4, 0x2c, 0x87, 0x3b, 0xb4,
	0x6f, 0xf6, 0xda, 0x26, 0xe7, 0xbe, 0xd3, 0x19, 0x70, 0xc2, 0xca, 0xd9, 0x5a, 0xba, 0x5e, 0x6c,
	0xc2, 0xe5, 0x2f, 0x3e, 0x89, 0x70, 0xad, 0xaf, 0xdf, 0x04, 0x30, 0x35, 0x0e, 0x20, 0x5c, 0xea,
	0xe5, 0x31, 0x75, 0x1d, 0x4e, 0x5c, 0x8f, 0x5f, 0x4e, 0x02, 0xf8, 0x50, 0x3e, 0xe3, 0x1a, 0x20,
	0xc2, 0xfb, 0x53, 0x44, 0x1c, 0x87, 0x85, 0x15, 0xe8, 0x86, 0xb5, 0xa5, 0x7e, 0x39, 0x37, 0x5f,
	0x01, 0xa5, 0x40, 0x38, 0x82, 0xe8, 0x3f, 0x69, 0xa0, 0x68, 0x72, 0x6e, 0x76, 0x2f, 0x44, 0x76,
	0xca, 0x5b, 0x82, 0x4d, 0x6d, 0x25, 0x1b, 0x05, 0x6c, 0x7d, 0xa6, 0xe8, 0x94, 0x12, 0xc6, 0x33,
	0x24, 0x1e, 0x28, 0x12, 0xcb, 0xd4, 0x08, 0x27, 0x63, 0xea, 0x3f, 0x80, 0x4c, 0xd8, 0xa0, 0xe5,
	0x7c, 0x4d, 0xab, 0x17, 0x9b, 0x95, 0xe5, 0xb1, 0xcf, 0x69, 0xaf, 0x27, 0x4b, 0x1e, 0x62, 0x67,
	0x42, 0xa9, 0x92, 0xcf, 0xca, 0x11, 0x16, 0x4e, 0x9f, 0xe7, 0x7f, 0x7e, 0x0d, 0x53, 0x7f, 0xbd,
	0x86, 0x29, 0x74, 0x1f, 0x94, 0x66, 0xfa, 0x1e, 0x13, 0xe6, 0xd1, 0x3e, 0x23, 0xe8, 0x97, 0x0c,
	0x28, 0x9e, 0x31, 0xfb, 0x4b, 0xcb, 0xe1, 0x62, 0x1e, 0x3e, 0x07, 0x5b, 0x61, 0xec, 0xe9, 0x34,
	0x7c, 0x3c, 0x0a, 0x60, 0x2e, 0x54, 0x89, 0x59, 0x88, 0x94, 0xd3, 0xb4, 0x2a, 0x01, 0xc2, 0xb9,
	0xf0, 0xeb, 0xf6, 0x4c, 0xc1, 0x7c, 0xf1, 0x33, 0xff, 0x63, 0xf1, 0xb3, 0xff, 0x41, 0xf1, 0xf5,
	0x23, 0x90, 0x23, 0x96, 0x33, 0x1d, 0x85, 0xbb, 0x93, 0x00, 0x6e, 0x4b, 0x03, 0x29, 0x47, 0x58,
	0x01, 0x12, 0x7d, 0x52, 0x02, 0xf7, 0x12, 0xdd, 0x10, 0x77, 0xc9, 0xef, 0x1a, 0xd0, 0xcf, 0x98,
	0x7d, 0x62, 0x59, 0x52, 0x6c, 0x76, 0xc3, 0xd1, 0xbb, 0x81, 0x66, 0x31, 0x40, 0xde, 0x57, 0xde,
	0x54, 0xb7, 0x24, 0x76, 0x51, 0xa4, 0x41, 0x38, 0x06, 0xe9, 0x87, 0x20, 0x33, 0x60, 0xc4, 0x17,
	0x5d, 0x52, 0x68, 0xed, 0x4e, 0x02, 0x58, 0x94, 0xe0, 0x50, 0x8a, 0xb0, 0x50, 0x26, 0xf8, 0x3c,
	0x00, 0x95, 0xc5, 0x77, 0xc7, 0xb4, 0xfe, 0xd0, 0xc4, 0x58, 0x60, 0xe2, 0xd2, 0x21, 0xb9, 0x65,
	0xcc, 0x20, 0x38, 0x58, 0xfa, 0xf4, 0x98, 0xdc, 0x9f, 0x9a, 0xb8, 0x75, 0x27, 0x7d, 0xf6, 0x8a,
	0xf8, 0x61, 0x13, 0xdd, 0x00, 0xa9, 0x4f, 0xc1, 0x96, 0x29, 0xfc, 0xb1, 0xf2, 0x9d, 0x5a, 0xba,
	0x5e, 0x68, 0x1d, 0x84, 0x76, 0x4a, 0x34, 0xb5, 0x53, 0x02, 0x84, 0x23, 0x55, 0x98, 0x0d, 0xf9,
	0x19, 0x13, 0x4c, 0x64, 0x23, 0xd2, 0x20, 0x1c, 0x83, 0x16, 0x56, 0xd7, 0x94, 0x46, 0x4c, 0x70,
	0xac, 0x89, 0x66, 0xc5, 0xc4, 0x76, 0x18, 0x27, 0x7e, 0x5c, 0xbb, 0x16, 0x00, 0xec, 0x82, 0xfa,
	0xbc, 0xdd, 0xa5, 0x16, 0x51, 0x4c, 0x0f, 0xc7, 0x01, 0x4c, 0x48, 0x27, 0x01, 0xbc, 0xab, 0xee,
	0x5d, 0x2c, 0x43, 0xb8, 0x20, 0xfe, 0x38, 0xa5, 0x16, 0xd1, 0x1f, 0x82, 0xec, 0xd0, 0xec, 0x0d,
	0xa2, 0x15, 0xb6, 0x37, 0x09, 0xe0, 0x07, 0xd2, 0x40, 0x88, 0x11, 0x96, 0xea, 0x99, 0x5b, 0x9a,
	0xde, 0xe4, 0x96, 0x26, 0x2e, 0x54, 0xe6, 0xda, 0x0b, 0x95, 0xc8, 0xc2, 0x01, 0xf8, 0x70, 0x09,
	0xd7, 0x38, 0x17, 0xef, 0x65, 0xb1, 0x31, 0xf1, 0xa8, 0x7f, 0x53, 0x8b, 0xfc, 0x29, 0x28, 0xfa,
	0xc2, 0x5f, 0x9b, 0x5f, 0x7a, 0x51, 0x26, 0x12, 0x7d, 0x19, 0x4a, 0x11, 0x06, 0x12, 0xf3, 0xed,
	0xa5, 0x47, 0x92, 0xab, 0x3f, 0x7d, 0xfd, 0xea, 0x8f, 0x1a, 0x3e, 0xb3, 0x59, 0xc3, 0xdf, 0x57,
	0xb3, 0x1a, 0x31, 0x8c, 0xb8, 0x37, 0xdf, 0x65, 0x41, 0xfa, 0x8c, 0xd9, 0xfa, 0x4b, 0x00, 0x12,
	0xff, 0xd8, 0xad, 0x38, 0x20, 0x33, 0x57, 0xb0, 0xf2, 0x68, 0x03, 0x50, 0x14, 0x47, 0xff, 0x0e,
	0xe4, 0xe3, 0x33, 0xf9, 0xd1, 0x4a, 0xc3, 0x08, 0x52, 0x39, 0xba, 0x16, 0x12, 0x7b, 0x7e, 0x09,
	0x40, 0xa2, 0x72, 0xab, 0x5f, 0x3e, 0x05, 0xad, 0x79, 0xf9, 0x62, 0x86, 0x74, 0x17, 0xec, 0xce,
	0xaf, 0xee, 0xfa, 0x4a, 0xfb, 0x39, 0x64, 0xe5, 0xe9, 0xa6, 0xc8, 0x38, 0xdc, 0x10, 0xe8, 0x4b,
	0x56, 0xea, 0xba, 0x17, 0xcf, 0x83, 0x2b, 0xcf, 0xfe, 0x05, 0x38, 0x8e, 0xeb, 0x81, 0xbd, 0x85,
	0x65, 0x70, 0xb4, 0xc6, 0xd1, 0x2c, 0xb4, 0x72, 0xbc, 0x31, 0x34, 0x59, 0xb8, 0xc4, 0x7e, 0x5d,
	0x5d, 0xb8, 0x29, 0x68, 0x4d, 0xe1, 0x16, 0x57, 0x5c, 0xeb, 0xfc, 0xcd, 0xa8, 0xaa, 0xbd, 0x1d,
	0x55, 0xb5, 0xf7, 0xa3, 0xaa, 0xf6, 0xeb, 0x55, 0x35, 0xf5, 0xf6, 0xaa, 0x9a, 0x7a, 0x77, 0x55,
	0x4d, 0x7d, 0xff, 0x89, 0xed, 0xf0, 0x8b, 0x41, 0xa7, 0xd1, 0xa5, 0xae, 0x21, 0x1d, 0x3e, 0xe9,
	0x99, 0x1d, 0xa6, 0xbe, 0x8d, 0x61, 0xd3, 0xf8, 0xd1, 0x60, 0xdc, 0xb4, 0x9d, 0xbe, 0xad, 0x7e,
	0x0f, 0x85, 0xe3, 0xca, 0x3a, 0x39, 0xf1, 0x43, 0xe8, 0xd9, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff,
	0xb7, 0x40, 0xfe, 0x6d, 0x9b, 0x0d, 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 {
	// CreatePost defines the method to create a post
	CreatePost(ctx context.Context, in *MsgCreatePost, opts ...grpc.CallOption) (*MsgCreatePostResponse, error)
	// EditPost defines the method to edit an existing post
	EditPost(ctx context.Context, in *MsgEditPost, opts ...grpc.CallOption) (*MsgEditPostResponse, error)
	// ReportPost defines a method for creating a new post report
	ReportPost(ctx context.Context, in *MsgReportPost, opts ...grpc.CallOption) (*MsgReportPostResponse, error)
	// AddReaction defines the method to add a reaction to a post
	AddPostReaction(ctx context.Context, in *MsgAddPostReaction, opts ...grpc.CallOption) (*MsgAddPostReactionResponse, error)
	// RemoveReaction defines the method to remove a reaction from a post
	RemovePostReaction(ctx context.Context, in *MsgRemovePostReaction, opts ...grpc.CallOption) (*MsgRemovePostReactionResponse, error)
	// RegisterReaction defines the method to register a new reaction
	RegisterReaction(ctx context.Context, in *MsgRegisterReaction, opts ...grpc.CallOption) (*MsgRegisterReactionResponse, error)
	// AnswerPoll defines the method to answer a poll
	AnswerPoll(ctx context.Context, in *MsgAnswerPoll, opts ...grpc.CallOption) (*MsgAnswerPollResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

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

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

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

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

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

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

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

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// CreatePost defines the method to create a post
	CreatePost(context.Context, *MsgCreatePost) (*MsgCreatePostResponse, error)
	// EditPost defines the method to edit an existing post
	EditPost(context.Context, *MsgEditPost) (*MsgEditPostResponse, error)
	// ReportPost defines a method for creating a new post report
	ReportPost(context.Context, *MsgReportPost) (*MsgReportPostResponse, error)
	// AddReaction defines the method to add a reaction to a post
	AddPostReaction(context.Context, *MsgAddPostReaction) (*MsgAddPostReactionResponse, error)
	// RemoveReaction defines the method to remove a reaction from a post
	RemovePostReaction(context.Context, *MsgRemovePostReaction) (*MsgRemovePostReactionResponse, error)
	// RegisterReaction defines the method to register a new reaction
	RegisterReaction(context.Context, *MsgRegisterReaction) (*MsgRegisterReactionResponse, error)
	// AnswerPoll defines the method to answer a poll
	AnswerPoll(context.Context, *MsgAnswerPoll) (*MsgAnswerPollResponse, error)
}

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

func (*UnimplementedMsgServer) CreatePost(ctx context.Context, req *MsgCreatePost) (*MsgCreatePostResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePost not implemented")
}
func (*UnimplementedMsgServer) EditPost(ctx context.Context, req *MsgEditPost) (*MsgEditPostResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EditPost not implemented")
}
func (*UnimplementedMsgServer) ReportPost(ctx context.Context, req *MsgReportPost) (*MsgReportPostResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReportPost not implemented")
}
func (*UnimplementedMsgServer) AddPostReaction(ctx context.Context, req *MsgAddPostReaction) (*MsgAddPostReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPostReaction not implemented")
}
func (*UnimplementedMsgServer) RemovePostReaction(ctx context.Context, req *MsgRemovePostReaction) (*MsgRemovePostReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemovePostReaction not implemented")
}
func (*UnimplementedMsgServer) RegisterReaction(ctx context.Context, req *MsgRegisterReaction) (*MsgRegisterReactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterReaction not implemented")
}
func (*UnimplementedMsgServer) AnswerPoll(ctx context.Context, req *MsgAnswerPoll) (*MsgAnswerPollResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AnswerPoll not implemented")
}

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

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

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

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

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

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

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

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

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "desmos.posts.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreatePost",
			Handler:    _Msg_CreatePost_Handler,
		},
		{
			MethodName: "EditPost",
			Handler:    _Msg_EditPost_Handler,
		},
		{
			MethodName: "ReportPost",
			Handler:    _Msg_ReportPost_Handler,
		},
		{
			MethodName: "AddPostReaction",
			Handler:    _Msg_AddPostReaction_Handler,
		},
		{
			MethodName: "RemovePostReaction",
			Handler:    _Msg_RemovePostReaction_Handler,
		},
		{
			MethodName: "RegisterReaction",
			Handler:    _Msg_RegisterReaction_Handler,
		},
		{
			MethodName: "AnswerPoll",
			Handler:    _Msg_AnswerPoll_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "desmos/posts/v1beta1/msgs.proto",
}

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

func (m *MsgCreatePost) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Poll != nil {
		{
			size, err := m.Poll.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.Attachments) > 0 {
		for iNdEx := len(m.Attachments) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attachments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMsgs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	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.AdditionalAttributes) > 0 {
		for iNdEx := len(m.AdditionalAttributes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AdditionalAttributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMsgs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Subspace) > 0 {
		i -= len(m.Subspace)
		copy(dAtA[i:], m.Subspace)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Subspace)))
		i--
		dAtA[i] = 0x22
	}
	if m.CommentsState != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.CommentsState))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ParentID) > 0 {
		i -= len(m.ParentID)
		copy(dAtA[i:], m.ParentID)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.ParentID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgEditPost) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Editor) > 0 {
		i -= len(m.Editor)
		copy(dAtA[i:], m.Editor)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Editor)))
		i--
		dAtA[i] = 0x32
	}
	if m.Poll != nil {
		{
			size, err := m.Poll.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMsgs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Attachments) > 0 {
		for iNdEx := len(m.Attachments) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Attachments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMsgs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.CommentsState != 0 {
		i = encodeVarintMsgs(dAtA, i, uint64(m.CommentsState))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PostID) > 0 {
		i -= len(m.PostID)
		copy(dAtA[i:], m.PostID)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.PostID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgAnswerPoll) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Answerer) > 0 {
		i -= len(m.Answerer)
		copy(dAtA[i:], m.Answerer)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Answerer)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Answers) > 0 {
		for iNdEx := len(m.Answers) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Answers[iNdEx])
			copy(dAtA[i:], m.Answers[iNdEx])
			i = encodeVarintMsgs(dAtA, i, uint64(len(m.Answers[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.PostID) > 0 {
		i -= len(m.PostID)
		copy(dAtA[i:], m.PostID)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.PostID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRegisterReaction) 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] = 0x22
	}
	if len(m.Subspace) > 0 {
		i -= len(m.Subspace)
		copy(dAtA[i:], m.Subspace)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Subspace)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ShortCode) > 0 {
		i -= len(m.ShortCode)
		copy(dAtA[i:], m.ShortCode)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.ShortCode)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgReportPost) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.User) > 0 {
		i -= len(m.User)
		copy(dAtA[i:], m.User)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.User)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ReportType) > 0 {
		i -= len(m.ReportType)
		copy(dAtA[i:], m.ReportType)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.ReportType)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PostID) > 0 {
		i -= len(m.PostID)
		copy(dAtA[i:], m.PostID)
		i = encodeVarintMsgs(dAtA, i, uint64(len(m.PostID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgReportPostResponse) 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 *MsgCreatePost) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ParentID)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if m.CommentsState != 0 {
		n += 1 + sovMsgs(uint64(m.CommentsState))
	}
	l = len(m.Subspace)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if len(m.AdditionalAttributes) > 0 {
		for _, e := range m.AdditionalAttributes {
			l = e.Size()
			n += 1 + l + sovMsgs(uint64(l))
		}
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if len(m.Attachments) > 0 {
		for _, e := range m.Attachments {
			l = e.Size()
			n += 1 + l + sovMsgs(uint64(l))
		}
	}
	if m.Poll != nil {
		l = m.Poll.Size()
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgEditPost) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PostID)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if m.CommentsState != 0 {
		n += 1 + sovMsgs(uint64(m.CommentsState))
	}
	if len(m.Attachments) > 0 {
		for _, e := range m.Attachments {
			l = e.Size()
			n += 1 + l + sovMsgs(uint64(l))
		}
	}
	if m.Poll != nil {
		l = m.Poll.Size()
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Editor)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

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

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

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

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

func (m *MsgAnswerPoll) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PostID)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	if len(m.Answers) > 0 {
		for _, s := range m.Answers {
			l = len(s)
			n += 1 + l + sovMsgs(uint64(l))
		}
	}
	l = len(m.Answerer)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

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

func (m *MsgRegisterReaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ShortCode)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Subspace)
	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 *MsgRegisterReactionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgReportPost) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PostID)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.ReportType)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	l = len(m.User)
	if l > 0 {
		n += 1 + l + sovMsgs(uint64(l))
	}
	return n
}

func (m *MsgReportPostResponse) 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 *MsgCreatePost) 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: MsgCreatePost: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreatePost: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentID", 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.ParentID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", 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.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommentsState", wireType)
			}
			m.CommentsState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommentsState |= CommentsState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subspace", 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.Subspace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdditionalAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AdditionalAttributes = append(m.AdditionalAttributes, Attribute{})
			if err := m.AdditionalAttributes[len(m.AdditionalAttributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attachments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attachments = append(m.Attachments, Attachment{})
			if err := m.Attachments[len(m.Attachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Poll", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Poll == nil {
				m.Poll = &Poll{}
			}
			if err := m.Poll.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreatePostResponse) 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: MsgCreatePostResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreatePostResponse: 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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEditPost) 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: MsgEditPost: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditPost: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", 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.PostID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", 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.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommentsState", wireType)
			}
			m.CommentsState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommentsState |= CommentsState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attachments", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Attachments = append(m.Attachments, Attachment{})
			if err := m.Attachments[len(m.Attachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Poll", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMsgs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMsgs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMsgs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Poll == nil {
				m.Poll = &Poll{}
			}
			if err := m.Poll.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Editor", 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.Editor = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEditPostResponse) 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: MsgEditPostResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditPostResponse: 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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAddPostReaction) 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: MsgAddPostReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddPostReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", 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.PostID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reaction", 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.Reaction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", 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.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAddPostReactionResponse) 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: MsgAddPostReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddPostReactionResponse: 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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemovePostReaction) 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: MsgRemovePostReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemovePostReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", 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.PostID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reaction", 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.Reaction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", 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.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemovePostReactionResponse) 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: MsgRemovePostReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemovePostReactionResponse: 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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAnswerPoll) 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: MsgAnswerPoll: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAnswerPoll: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", 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.PostID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Answers", 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.Answers = append(m.Answers, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Answerer", 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.Answerer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgAnswerPollResponse) 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: MsgAnswerPollResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAnswerPollResponse: 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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRegisterReaction) 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: MsgRegisterReaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRegisterReaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShortCode", 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.ShortCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", 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.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subspace", 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.Subspace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRegisterReactionResponse) 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: MsgRegisterReactionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRegisterReactionResponse: 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) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgReportPost) 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: MsgReportPost: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgReportPost: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PostID", 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.PostID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportType", 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.ReportType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", 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.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", 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.User = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMsgs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMsgs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgReportPostResponse) 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: MsgReportPostResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgReportPostResponse: 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) || (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")
)