// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/live/dao-anchor/api/grpc/v0/api.proto

package v0

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

import io "io"

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type CreateCacheListReq struct {
	RoomIds              []int64  `protobuf:"varint,1,rep,packed,name=room_ids,json=roomIds" json:"room_ids,omitempty"`
	Content              string   `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateCacheListReq) Reset()         { *m = CreateCacheListReq{} }
func (m *CreateCacheListReq) String() string { return proto.CompactTextString(m) }
func (*CreateCacheListReq) ProtoMessage()    {}
func (*CreateCacheListReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{0}
}
func (m *CreateCacheListReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateCacheListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateCacheListReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CreateCacheListReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateCacheListReq.Merge(dst, src)
}
func (m *CreateCacheListReq) XXX_Size() int {
	return m.Size()
}
func (m *CreateCacheListReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateCacheListReq.DiscardUnknown(m)
}

var xxx_messageInfo_CreateCacheListReq proto.InternalMessageInfo

func (m *CreateCacheListReq) GetRoomIds() []int64 {
	if m != nil {
		return m.RoomIds
	}
	return nil
}

func (m *CreateCacheListReq) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type CreateCacheListResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateCacheListResp) Reset()         { *m = CreateCacheListResp{} }
func (m *CreateCacheListResp) String() string { return proto.CompactTextString(m) }
func (*CreateCacheListResp) ProtoMessage()    {}
func (*CreateCacheListResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{1}
}
func (m *CreateCacheListResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateCacheListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateCacheListResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CreateCacheListResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateCacheListResp.Merge(dst, src)
}
func (m *CreateCacheListResp) XXX_Size() int {
	return m.Size()
}
func (m *CreateCacheListResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateCacheListResp.DiscardUnknown(m)
}

var xxx_messageInfo_CreateCacheListResp proto.InternalMessageInfo

type CreateLiveCacheListReq struct {
	RoomIds              []int64  `protobuf:"varint,1,rep,packed,name=room_ids,json=roomIds" json:"room_ids,omitempty"`
	Content              string   `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateLiveCacheListReq) Reset()         { *m = CreateLiveCacheListReq{} }
func (m *CreateLiveCacheListReq) String() string { return proto.CompactTextString(m) }
func (*CreateLiveCacheListReq) ProtoMessage()    {}
func (*CreateLiveCacheListReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{2}
}
func (m *CreateLiveCacheListReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateLiveCacheListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateLiveCacheListReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CreateLiveCacheListReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateLiveCacheListReq.Merge(dst, src)
}
func (m *CreateLiveCacheListReq) XXX_Size() int {
	return m.Size()
}
func (m *CreateLiveCacheListReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateLiveCacheListReq.DiscardUnknown(m)
}

var xxx_messageInfo_CreateLiveCacheListReq proto.InternalMessageInfo

func (m *CreateLiveCacheListReq) GetRoomIds() []int64 {
	if m != nil {
		return m.RoomIds
	}
	return nil
}

func (m *CreateLiveCacheListReq) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type CreateLiveCacheListResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateLiveCacheListResp) Reset()         { *m = CreateLiveCacheListResp{} }
func (m *CreateLiveCacheListResp) String() string { return proto.CompactTextString(m) }
func (*CreateLiveCacheListResp) ProtoMessage()    {}
func (*CreateLiveCacheListResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{3}
}
func (m *CreateLiveCacheListResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateLiveCacheListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateLiveCacheListResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CreateLiveCacheListResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateLiveCacheListResp.Merge(dst, src)
}
func (m *CreateLiveCacheListResp) XXX_Size() int {
	return m.Size()
}
func (m *CreateLiveCacheListResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateLiveCacheListResp.DiscardUnknown(m)
}

var xxx_messageInfo_CreateLiveCacheListResp proto.InternalMessageInfo

type GetContentMapReq struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetContentMapReq) Reset()         { *m = GetContentMapReq{} }
func (m *GetContentMapReq) String() string { return proto.CompactTextString(m) }
func (*GetContentMapReq) ProtoMessage()    {}
func (*GetContentMapReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{4}
}
func (m *GetContentMapReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetContentMapReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetContentMapReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetContentMapReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetContentMapReq.Merge(dst, src)
}
func (m *GetContentMapReq) XXX_Size() int {
	return m.Size()
}
func (m *GetContentMapReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetContentMapReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetContentMapReq proto.InternalMessageInfo

type GetContentMapResp struct {
	List                 map[string]int64 `protobuf:"bytes,1,rep,name=list" json:"list,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *GetContentMapResp) Reset()         { *m = GetContentMapResp{} }
func (m *GetContentMapResp) String() string { return proto.CompactTextString(m) }
func (*GetContentMapResp) ProtoMessage()    {}
func (*GetContentMapResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{5}
}
func (m *GetContentMapResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetContentMapResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetContentMapResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetContentMapResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetContentMapResp.Merge(dst, src)
}
func (m *GetContentMapResp) XXX_Size() int {
	return m.Size()
}
func (m *GetContentMapResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetContentMapResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetContentMapResp proto.InternalMessageInfo

func (m *GetContentMapResp) GetList() map[string]int64 {
	if m != nil {
		return m.List
	}
	return nil
}

type CreateDBDataReq struct {
	RoomIds              []int64  `protobuf:"varint,1,rep,packed,name=room_ids,json=roomIds" json:"room_ids,omitempty"`
	Content              string   `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateDBDataReq) Reset()         { *m = CreateDBDataReq{} }
func (m *CreateDBDataReq) String() string { return proto.CompactTextString(m) }
func (*CreateDBDataReq) ProtoMessage()    {}
func (*CreateDBDataReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{6}
}
func (m *CreateDBDataReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateDBDataReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateDBDataReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CreateDBDataReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateDBDataReq.Merge(dst, src)
}
func (m *CreateDBDataReq) XXX_Size() int {
	return m.Size()
}
func (m *CreateDBDataReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateDBDataReq.DiscardUnknown(m)
}

var xxx_messageInfo_CreateDBDataReq proto.InternalMessageInfo

func (m *CreateDBDataReq) GetRoomIds() []int64 {
	if m != nil {
		return m.RoomIds
	}
	return nil
}

func (m *CreateDBDataReq) GetContent() string {
	if m != nil {
		return m.Content
	}
	return ""
}

type CreateDBDataResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateDBDataResp) Reset()         { *m = CreateDBDataResp{} }
func (m *CreateDBDataResp) String() string { return proto.CompactTextString(m) }
func (*CreateDBDataResp) ProtoMessage()    {}
func (*CreateDBDataResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{7}
}
func (m *CreateDBDataResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateDBDataResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateDBDataResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CreateDBDataResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateDBDataResp.Merge(dst, src)
}
func (m *CreateDBDataResp) XXX_Size() int {
	return m.Size()
}
func (m *CreateDBDataResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateDBDataResp.DiscardUnknown(m)
}

var xxx_messageInfo_CreateDBDataResp proto.InternalMessageInfo

type GetAnchorGradeListReq struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetAnchorGradeListReq) Reset()         { *m = GetAnchorGradeListReq{} }
func (m *GetAnchorGradeListReq) String() string { return proto.CompactTextString(m) }
func (*GetAnchorGradeListReq) ProtoMessage()    {}
func (*GetAnchorGradeListReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{8}
}
func (m *GetAnchorGradeListReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAnchorGradeListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAnchorGradeListReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetAnchorGradeListReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAnchorGradeListReq.Merge(dst, src)
}
func (m *GetAnchorGradeListReq) XXX_Size() int {
	return m.Size()
}
func (m *GetAnchorGradeListReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAnchorGradeListReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetAnchorGradeListReq proto.InternalMessageInfo

type GetAnchorGradeListResp struct {
	List                 []*GetAnchorGradeListResp_List `protobuf:"bytes,1,rep,name=list" json:"list"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_unrecognized     []byte                         `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

func (m *GetAnchorGradeListResp) Reset()         { *m = GetAnchorGradeListResp{} }
func (m *GetAnchorGradeListResp) String() string { return proto.CompactTextString(m) }
func (*GetAnchorGradeListResp) ProtoMessage()    {}
func (*GetAnchorGradeListResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{9}
}
func (m *GetAnchorGradeListResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAnchorGradeListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAnchorGradeListResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetAnchorGradeListResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAnchorGradeListResp.Merge(dst, src)
}
func (m *GetAnchorGradeListResp) XXX_Size() int {
	return m.Size()
}
func (m *GetAnchorGradeListResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAnchorGradeListResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetAnchorGradeListResp proto.InternalMessageInfo

func (m *GetAnchorGradeListResp) GetList() []*GetAnchorGradeListResp_List {
	if m != nil {
		return m.List
	}
	return nil
}

type GetAnchorGradeListResp_List struct {
	// 主播评级id 1=>S;2=>A;3=>B...
	GradeId int64 `protobuf:"varint,1,opt,name=grade_id,json=gradeId,proto3" json:"grade_id"`
	// 主播评级名称 S;A;B...
	GradeName string `protobuf:"bytes,2,opt,name=grade_name,json=gradeName,proto3" json:"grade_name"`
	// 人数基数
	BaseOnline int64 `protobuf:"varint,3,opt,name=base_online,json=baseOnline,proto3" json:"online_base"`
	// 人气倍数
	PopularityRate       int64    `protobuf:"varint,4,opt,name=popularity_rate,json=popularityRate,proto3" json:"popularity_rate"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetAnchorGradeListResp_List) Reset()         { *m = GetAnchorGradeListResp_List{} }
func (m *GetAnchorGradeListResp_List) String() string { return proto.CompactTextString(m) }
func (*GetAnchorGradeListResp_List) ProtoMessage()    {}
func (*GetAnchorGradeListResp_List) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{9, 0}
}
func (m *GetAnchorGradeListResp_List) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAnchorGradeListResp_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAnchorGradeListResp_List.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetAnchorGradeListResp_List) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAnchorGradeListResp_List.Merge(dst, src)
}
func (m *GetAnchorGradeListResp_List) XXX_Size() int {
	return m.Size()
}
func (m *GetAnchorGradeListResp_List) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAnchorGradeListResp_List.DiscardUnknown(m)
}

var xxx_messageInfo_GetAnchorGradeListResp_List proto.InternalMessageInfo

func (m *GetAnchorGradeListResp_List) GetGradeId() int64 {
	if m != nil {
		return m.GradeId
	}
	return 0
}

func (m *GetAnchorGradeListResp_List) GetGradeName() string {
	if m != nil {
		return m.GradeName
	}
	return ""
}

func (m *GetAnchorGradeListResp_List) GetBaseOnline() int64 {
	if m != nil {
		return m.BaseOnline
	}
	return 0
}

func (m *GetAnchorGradeListResp_List) GetPopularityRate() int64 {
	if m != nil {
		return m.PopularityRate
	}
	return 0
}

type EditAnchorGradeReq struct {
	GradeId              int64    `protobuf:"varint,1,opt,name=grade_id,json=gradeId,proto3" json:"grade_id,omitempty" validate:"dive,gt=0,required"`
	OnlineBase           int64    `protobuf:"varint,2,opt,name=online_base,json=onlineBase,proto3" json:"online_base,omitempty" validate:"dive,gt=0,required"`
	PopularityRate       int64    `protobuf:"varint,3,opt,name=popularity_rate,json=popularityRate,proto3" json:"popularity_rate,omitempty" validate:"dive,gt=0,required"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EditAnchorGradeReq) Reset()         { *m = EditAnchorGradeReq{} }
func (m *EditAnchorGradeReq) String() string { return proto.CompactTextString(m) }
func (*EditAnchorGradeReq) ProtoMessage()    {}
func (*EditAnchorGradeReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{10}
}
func (m *EditAnchorGradeReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EditAnchorGradeReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EditAnchorGradeReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *EditAnchorGradeReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EditAnchorGradeReq.Merge(dst, src)
}
func (m *EditAnchorGradeReq) XXX_Size() int {
	return m.Size()
}
func (m *EditAnchorGradeReq) XXX_DiscardUnknown() {
	xxx_messageInfo_EditAnchorGradeReq.DiscardUnknown(m)
}

var xxx_messageInfo_EditAnchorGradeReq proto.InternalMessageInfo

func (m *EditAnchorGradeReq) GetGradeId() int64 {
	if m != nil {
		return m.GradeId
	}
	return 0
}

func (m *EditAnchorGradeReq) GetOnlineBase() int64 {
	if m != nil {
		return m.OnlineBase
	}
	return 0
}

func (m *EditAnchorGradeReq) GetPopularityRate() int64 {
	if m != nil {
		return m.PopularityRate
	}
	return 0
}

type EditAnchorGradeResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EditAnchorGradeResp) Reset()         { *m = EditAnchorGradeResp{} }
func (m *EditAnchorGradeResp) String() string { return proto.CompactTextString(m) }
func (*EditAnchorGradeResp) ProtoMessage()    {}
func (*EditAnchorGradeResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{11}
}
func (m *EditAnchorGradeResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EditAnchorGradeResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EditAnchorGradeResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *EditAnchorGradeResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EditAnchorGradeResp.Merge(dst, src)
}
func (m *EditAnchorGradeResp) XXX_Size() int {
	return m.Size()
}
func (m *EditAnchorGradeResp) XXX_DiscardUnknown() {
	xxx_messageInfo_EditAnchorGradeResp.DiscardUnknown(m)
}

var xxx_messageInfo_EditAnchorGradeResp proto.InternalMessageInfo

type AddAnchorGradeReq struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" validate:"dive,gt=0,required"`
	OnlineBase           int64    `protobuf:"varint,2,opt,name=online_base,json=onlineBase,proto3" json:"online_base,omitempty" validate:"dive,gt=0,required"`
	PopularityRate       int64    `protobuf:"varint,3,opt,name=popularity_rate,json=popularityRate,proto3" json:"popularity_rate,omitempty" validate:"dive,gt=0,required"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddAnchorGradeReq) Reset()         { *m = AddAnchorGradeReq{} }
func (m *AddAnchorGradeReq) String() string { return proto.CompactTextString(m) }
func (*AddAnchorGradeReq) ProtoMessage()    {}
func (*AddAnchorGradeReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{12}
}
func (m *AddAnchorGradeReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddAnchorGradeReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddAnchorGradeReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *AddAnchorGradeReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddAnchorGradeReq.Merge(dst, src)
}
func (m *AddAnchorGradeReq) XXX_Size() int {
	return m.Size()
}
func (m *AddAnchorGradeReq) XXX_DiscardUnknown() {
	xxx_messageInfo_AddAnchorGradeReq.DiscardUnknown(m)
}

var xxx_messageInfo_AddAnchorGradeReq proto.InternalMessageInfo

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

func (m *AddAnchorGradeReq) GetOnlineBase() int64 {
	if m != nil {
		return m.OnlineBase
	}
	return 0
}

func (m *AddAnchorGradeReq) GetPopularityRate() int64 {
	if m != nil {
		return m.PopularityRate
	}
	return 0
}

type AddAnchorGradeResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddAnchorGradeResp) Reset()         { *m = AddAnchorGradeResp{} }
func (m *AddAnchorGradeResp) String() string { return proto.CompactTextString(m) }
func (*AddAnchorGradeResp) ProtoMessage()    {}
func (*AddAnchorGradeResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{13}
}
func (m *AddAnchorGradeResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddAnchorGradeResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddAnchorGradeResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *AddAnchorGradeResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddAnchorGradeResp.Merge(dst, src)
}
func (m *AddAnchorGradeResp) XXX_Size() int {
	return m.Size()
}
func (m *AddAnchorGradeResp) XXX_DiscardUnknown() {
	xxx_messageInfo_AddAnchorGradeResp.DiscardUnknown(m)
}

var xxx_messageInfo_AddAnchorGradeResp proto.InternalMessageInfo

type GetContentListReq struct {
	Page                 int64    `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"`
	PageSize             int64    `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetContentListReq) Reset()         { *m = GetContentListReq{} }
func (m *GetContentListReq) String() string { return proto.CompactTextString(m) }
func (*GetContentListReq) ProtoMessage()    {}
func (*GetContentListReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{14}
}
func (m *GetContentListReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetContentListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetContentListReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetContentListReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetContentListReq.Merge(dst, src)
}
func (m *GetContentListReq) XXX_Size() int {
	return m.Size()
}
func (m *GetContentListReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetContentListReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetContentListReq proto.InternalMessageInfo

func (m *GetContentListReq) GetPage() int64 {
	if m != nil {
		return m.Page
	}
	return 0
}

func (m *GetContentListReq) GetPageSize() int64 {
	if m != nil {
		return m.PageSize
	}
	return 0
}

type GetContentListResp struct {
	Page                 int64                      `protobuf:"varint,1,opt,name=page,proto3" json:"page,omitempty"`
	PageSize             int64                      `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	TotalCount           int64                      `protobuf:"varint,3,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"`
	List                 []*GetContentListResp_List `protobuf:"bytes,4,rep,name=list" json:"list"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *GetContentListResp) Reset()         { *m = GetContentListResp{} }
func (m *GetContentListResp) String() string { return proto.CompactTextString(m) }
func (*GetContentListResp) ProtoMessage()    {}
func (*GetContentListResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{15}
}
func (m *GetContentListResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetContentListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetContentListResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetContentListResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetContentListResp.Merge(dst, src)
}
func (m *GetContentListResp) XXX_Size() int {
	return m.Size()
}
func (m *GetContentListResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetContentListResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetContentListResp proto.InternalMessageInfo

func (m *GetContentListResp) GetPage() int64 {
	if m != nil {
		return m.Page
	}
	return 0
}

func (m *GetContentListResp) GetPageSize() int64 {
	if m != nil {
		return m.PageSize
	}
	return 0
}

func (m *GetContentListResp) GetTotalCount() int64 {
	if m != nil {
		return m.TotalCount
	}
	return 0
}

func (m *GetContentListResp) GetList() []*GetContentListResp_List {
	if m != nil {
		return m.List
	}
	return nil
}

type GetContentListResp_List struct {
	// 父分区id
	ParentAreaId int64 `protobuf:"varint,1,opt,name=parent_area_id,json=parentAreaId,proto3" json:"parent_area_id"`
	// 父分区名称
	ParentAreaName string `protobuf:"bytes,2,opt,name=parent_area_name,json=parentAreaName,proto3" json:"parent_area_name"`
	// 二级分区信息<id,name>
	AreaList map[int64]string `protobuf:"bytes,3,rep,name=area_list,json=areaList" json:"area_list" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// 人气倍率系数
	PopularityRate       int64    `protobuf:"varint,4,opt,name=popularity_rate,json=popularityRate,proto3" json:"popularity_rate"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetContentListResp_List) Reset()         { *m = GetContentListResp_List{} }
func (m *GetContentListResp_List) String() string { return proto.CompactTextString(m) }
func (*GetContentListResp_List) ProtoMessage()    {}
func (*GetContentListResp_List) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{15, 0}
}
func (m *GetContentListResp_List) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetContentListResp_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetContentListResp_List.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetContentListResp_List) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetContentListResp_List.Merge(dst, src)
}
func (m *GetContentListResp_List) XXX_Size() int {
	return m.Size()
}
func (m *GetContentListResp_List) XXX_DiscardUnknown() {
	xxx_messageInfo_GetContentListResp_List.DiscardUnknown(m)
}

var xxx_messageInfo_GetContentListResp_List proto.InternalMessageInfo

func (m *GetContentListResp_List) GetParentAreaId() int64 {
	if m != nil {
		return m.ParentAreaId
	}
	return 0
}

func (m *GetContentListResp_List) GetParentAreaName() string {
	if m != nil {
		return m.ParentAreaName
	}
	return ""
}

func (m *GetContentListResp_List) GetAreaList() map[int64]string {
	if m != nil {
		return m.AreaList
	}
	return nil
}

func (m *GetContentListResp_List) GetPopularityRate() int64 {
	if m != nil {
		return m.PopularityRate
	}
	return 0
}

type EditContentReq struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" validate:"dive,gt=0,required"`
	PopularityRate       int64    `protobuf:"varint,2,opt,name=popularity_rate,json=popularityRate,proto3" json:"popularity_rate,omitempty"`
	List                 []int64  `protobuf:"varint,3,rep,packed,name=list" json:"list,omitempty"`
	ParentId             int64    `protobuf:"varint,4,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
	IsAll                int64    `protobuf:"varint,5,opt,name=is_all,json=isAll,proto3" json:"is_all,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EditContentReq) Reset()         { *m = EditContentReq{} }
func (m *EditContentReq) String() string { return proto.CompactTextString(m) }
func (*EditContentReq) ProtoMessage()    {}
func (*EditContentReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{16}
}
func (m *EditContentReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EditContentReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EditContentReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *EditContentReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EditContentReq.Merge(dst, src)
}
func (m *EditContentReq) XXX_Size() int {
	return m.Size()
}
func (m *EditContentReq) XXX_DiscardUnknown() {
	xxx_messageInfo_EditContentReq.DiscardUnknown(m)
}

var xxx_messageInfo_EditContentReq proto.InternalMessageInfo

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

func (m *EditContentReq) GetPopularityRate() int64 {
	if m != nil {
		return m.PopularityRate
	}
	return 0
}

func (m *EditContentReq) GetList() []int64 {
	if m != nil {
		return m.List
	}
	return nil
}

func (m *EditContentReq) GetParentId() int64 {
	if m != nil {
		return m.ParentId
	}
	return 0
}

func (m *EditContentReq) GetIsAll() int64 {
	if m != nil {
		return m.IsAll
	}
	return 0
}

type EditContentResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EditContentResp) Reset()         { *m = EditContentResp{} }
func (m *EditContentResp) String() string { return proto.CompactTextString(m) }
func (*EditContentResp) ProtoMessage()    {}
func (*EditContentResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{17}
}
func (m *EditContentResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EditContentResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EditContentResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *EditContentResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EditContentResp.Merge(dst, src)
}
func (m *EditContentResp) XXX_Size() int {
	return m.Size()
}
func (m *EditContentResp) XXX_DiscardUnknown() {
	xxx_messageInfo_EditContentResp.DiscardUnknown(m)
}

var xxx_messageInfo_EditContentResp proto.InternalMessageInfo

type AddContentReq struct {
	ParentId             int64    `protobuf:"varint,1,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty" validate:"dive,gt=0,required"`
	List                 []int64  `protobuf:"varint,2,rep,packed,name=list" json:"list,omitempty" validate:"dive,gt=0,required"`
	PopularityRate       int64    `protobuf:"varint,3,opt,name=popularity_rate,json=popularityRate,proto3" json:"popularity_rate,omitempty" validate:"dive,gt=0,required"`
	IsAll                int64    `protobuf:"varint,4,opt,name=is_all,json=isAll,proto3" json:"is_all,omitempty" validate:"dive,gt=0,required"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddContentReq) Reset()         { *m = AddContentReq{} }
func (m *AddContentReq) String() string { return proto.CompactTextString(m) }
func (*AddContentReq) ProtoMessage()    {}
func (*AddContentReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{18}
}
func (m *AddContentReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddContentReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddContentReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *AddContentReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddContentReq.Merge(dst, src)
}
func (m *AddContentReq) XXX_Size() int {
	return m.Size()
}
func (m *AddContentReq) XXX_DiscardUnknown() {
	xxx_messageInfo_AddContentReq.DiscardUnknown(m)
}

var xxx_messageInfo_AddContentReq proto.InternalMessageInfo

func (m *AddContentReq) GetParentId() int64 {
	if m != nil {
		return m.ParentId
	}
	return 0
}

func (m *AddContentReq) GetList() []int64 {
	if m != nil {
		return m.List
	}
	return nil
}

func (m *AddContentReq) GetPopularityRate() int64 {
	if m != nil {
		return m.PopularityRate
	}
	return 0
}

func (m *AddContentReq) GetIsAll() int64 {
	if m != nil {
		return m.IsAll
	}
	return 0
}

type AddContentResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AddContentResp) Reset()         { *m = AddContentResp{} }
func (m *AddContentResp) String() string { return proto.CompactTextString(m) }
func (*AddContentResp) ProtoMessage()    {}
func (*AddContentResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{19}
}
func (m *AddContentResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AddContentResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AddContentResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *AddContentResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AddContentResp.Merge(dst, src)
}
func (m *AddContentResp) XXX_Size() int {
	return m.Size()
}
func (m *AddContentResp) XXX_DiscardUnknown() {
	xxx_messageInfo_AddContentResp.DiscardUnknown(m)
}

var xxx_messageInfo_AddContentResp proto.InternalMessageInfo

type DeleteContentReq struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" validate:"dive,gt=0,required"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteContentReq) Reset()         { *m = DeleteContentReq{} }
func (m *DeleteContentReq) String() string { return proto.CompactTextString(m) }
func (*DeleteContentReq) ProtoMessage()    {}
func (*DeleteContentReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{20}
}
func (m *DeleteContentReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteContentReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteContentReq.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *DeleteContentReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteContentReq.Merge(dst, src)
}
func (m *DeleteContentReq) XXX_Size() int {
	return m.Size()
}
func (m *DeleteContentReq) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteContentReq.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteContentReq proto.InternalMessageInfo

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

type DeleteContentResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteContentResp) Reset()         { *m = DeleteContentResp{} }
func (m *DeleteContentResp) String() string { return proto.CompactTextString(m) }
func (*DeleteContentResp) ProtoMessage()    {}
func (*DeleteContentResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_def40e84f903f7bf, []int{21}
}
func (m *DeleteContentResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteContentResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteContentResp.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *DeleteContentResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteContentResp.Merge(dst, src)
}
func (m *DeleteContentResp) XXX_Size() int {
	return m.Size()
}
func (m *DeleteContentResp) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteContentResp.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteContentResp proto.InternalMessageInfo

func init() {
	proto.RegisterType((*CreateCacheListReq)(nil), "live.daoanchor.v0.CreateCacheListReq")
	proto.RegisterType((*CreateCacheListResp)(nil), "live.daoanchor.v0.CreateCacheListResp")
	proto.RegisterType((*CreateLiveCacheListReq)(nil), "live.daoanchor.v0.CreateLiveCacheListReq")
	proto.RegisterType((*CreateLiveCacheListResp)(nil), "live.daoanchor.v0.CreateLiveCacheListResp")
	proto.RegisterType((*GetContentMapReq)(nil), "live.daoanchor.v0.GetContentMapReq")
	proto.RegisterType((*GetContentMapResp)(nil), "live.daoanchor.v0.GetContentMapResp")
	proto.RegisterMapType((map[string]int64)(nil), "live.daoanchor.v0.GetContentMapResp.ListEntry")
	proto.RegisterType((*CreateDBDataReq)(nil), "live.daoanchor.v0.CreateDBDataReq")
	proto.RegisterType((*CreateDBDataResp)(nil), "live.daoanchor.v0.CreateDBDataResp")
	proto.RegisterType((*GetAnchorGradeListReq)(nil), "live.daoanchor.v0.GetAnchorGradeListReq")
	proto.RegisterType((*GetAnchorGradeListResp)(nil), "live.daoanchor.v0.GetAnchorGradeListResp")
	proto.RegisterType((*GetAnchorGradeListResp_List)(nil), "live.daoanchor.v0.GetAnchorGradeListResp.List")
	proto.RegisterType((*EditAnchorGradeReq)(nil), "live.daoanchor.v0.EditAnchorGradeReq")
	proto.RegisterType((*EditAnchorGradeResp)(nil), "live.daoanchor.v0.EditAnchorGradeResp")
	proto.RegisterType((*AddAnchorGradeReq)(nil), "live.daoanchor.v0.AddAnchorGradeReq")
	proto.RegisterType((*AddAnchorGradeResp)(nil), "live.daoanchor.v0.AddAnchorGradeResp")
	proto.RegisterType((*GetContentListReq)(nil), "live.daoanchor.v0.GetContentListReq")
	proto.RegisterType((*GetContentListResp)(nil), "live.daoanchor.v0.GetContentListResp")
	proto.RegisterType((*GetContentListResp_List)(nil), "live.daoanchor.v0.GetContentListResp.List")
	proto.RegisterMapType((map[int64]string)(nil), "live.daoanchor.v0.GetContentListResp.List.AreaListEntry")
	proto.RegisterType((*EditContentReq)(nil), "live.daoanchor.v0.EditContentReq")
	proto.RegisterType((*EditContentResp)(nil), "live.daoanchor.v0.EditContentResp")
	proto.RegisterType((*AddContentReq)(nil), "live.daoanchor.v0.AddContentReq")
	proto.RegisterType((*AddContentResp)(nil), "live.daoanchor.v0.AddContentResp")
	proto.RegisterType((*DeleteContentReq)(nil), "live.daoanchor.v0.DeleteContentReq")
	proto.RegisterType((*DeleteContentResp)(nil), "live.daoanchor.v0.DeleteContentResp")
}

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

// CreateDataClient is the client API for CreateData service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CreateDataClient interface {
	// CreateCacheList 生成历史数据缓存列表
	CreateCacheList(ctx context.Context, in *CreateCacheListReq, opts ...grpc.CallOption) (*CreateCacheListResp, error)
	// CreateLiveCacheList 生成开播历史数据缓存列表
	CreateLiveCacheList(ctx context.Context, in *CreateLiveCacheListReq, opts ...grpc.CallOption) (*CreateLiveCacheListResp, error)
	// GetContentMap 获取需要生成历史数据的对象列表
	GetContentMap(ctx context.Context, in *GetContentMapReq, opts ...grpc.CallOption) (*GetContentMapResp, error)
	CreateDBData(ctx context.Context, in *CreateDBDataReq, opts ...grpc.CallOption) (*CreateDBDataResp, error)
}

type createDataClient struct {
	cc *grpc.ClientConn
}

func NewCreateDataClient(cc *grpc.ClientConn) CreateDataClient {
	return &createDataClient{cc}
}

func (c *createDataClient) CreateCacheList(ctx context.Context, in *CreateCacheListReq, opts ...grpc.CallOption) (*CreateCacheListResp, error) {
	out := new(CreateCacheListResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.CreateData/CreateCacheList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *createDataClient) CreateLiveCacheList(ctx context.Context, in *CreateLiveCacheListReq, opts ...grpc.CallOption) (*CreateLiveCacheListResp, error) {
	out := new(CreateLiveCacheListResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.CreateData/CreateLiveCacheList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *createDataClient) GetContentMap(ctx context.Context, in *GetContentMapReq, opts ...grpc.CallOption) (*GetContentMapResp, error) {
	out := new(GetContentMapResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.CreateData/GetContentMap", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *createDataClient) CreateDBData(ctx context.Context, in *CreateDBDataReq, opts ...grpc.CallOption) (*CreateDBDataResp, error) {
	out := new(CreateDBDataResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.CreateData/CreateDBData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CreateDataServer is the server API for CreateData service.
type CreateDataServer interface {
	// CreateCacheList 生成历史数据缓存列表
	CreateCacheList(context.Context, *CreateCacheListReq) (*CreateCacheListResp, error)
	// CreateLiveCacheList 生成开播历史数据缓存列表
	CreateLiveCacheList(context.Context, *CreateLiveCacheListReq) (*CreateLiveCacheListResp, error)
	// GetContentMap 获取需要生成历史数据的对象列表
	GetContentMap(context.Context, *GetContentMapReq) (*GetContentMapResp, error)
	CreateDBData(context.Context, *CreateDBDataReq) (*CreateDBDataResp, error)
}

func RegisterCreateDataServer(s *grpc.Server, srv CreateDataServer) {
	s.RegisterService(&_CreateData_serviceDesc, srv)
}

func _CreateData_CreateCacheList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateCacheListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreateDataServer).CreateCacheList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.CreateData/CreateCacheList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreateDataServer).CreateCacheList(ctx, req.(*CreateCacheListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreateData_CreateLiveCacheList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateLiveCacheListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreateDataServer).CreateLiveCacheList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.CreateData/CreateLiveCacheList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreateDataServer).CreateLiveCacheList(ctx, req.(*CreateLiveCacheListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreateData_GetContentMap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetContentMapReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreateDataServer).GetContentMap(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.CreateData/GetContentMap",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreateDataServer).GetContentMap(ctx, req.(*GetContentMapReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _CreateData_CreateDBData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDBDataReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CreateDataServer).CreateDBData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.CreateData/CreateDBData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CreateDataServer).CreateDBData(ctx, req.(*CreateDBDataReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _CreateData_serviceDesc = grpc.ServiceDesc{
	ServiceName: "live.daoanchor.v0.CreateData",
	HandlerType: (*CreateDataServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateCacheList",
			Handler:    _CreateData_CreateCacheList_Handler,
		},
		{
			MethodName: "CreateLiveCacheList",
			Handler:    _CreateData_CreateLiveCacheList_Handler,
		},
		{
			MethodName: "GetContentMap",
			Handler:    _CreateData_GetContentMap_Handler,
		},
		{
			MethodName: "CreateDBData",
			Handler:    _CreateData_CreateDBData_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/live/dao-anchor/api/grpc/v0/api.proto",
}

// PopularityClient is the client API for Popularity service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PopularityClient interface {
	// GetAnchorGradeList 获取人气值主播评级列表
	GetAnchorGradeList(ctx context.Context, in *GetAnchorGradeListReq, opts ...grpc.CallOption) (*GetAnchorGradeListResp, error)
	// EditAnchorGrade  编辑主播评级对应的人气值数据
	EditAnchorGrade(ctx context.Context, in *EditAnchorGradeReq, opts ...grpc.CallOption) (*EditAnchorGradeResp, error)
	// GetContentList  人气内容系数列表
	GetContentList(ctx context.Context, in *GetContentListReq, opts ...grpc.CallOption) (*GetContentListResp, error)
	// AddContent 添加内容系数
	AddContent(ctx context.Context, in *AddContentReq, opts ...grpc.CallOption) (*AddContentResp, error)
	// EditContent 编辑内容系数
	EditContent(ctx context.Context, in *EditContentReq, opts ...grpc.CallOption) (*EditContentResp, error)
	// DeleteContent 删除内容系数
	DeleteContent(ctx context.Context, in *DeleteContentReq, opts ...grpc.CallOption) (*DeleteContentResp, error)
}

type popularityClient struct {
	cc *grpc.ClientConn
}

func NewPopularityClient(cc *grpc.ClientConn) PopularityClient {
	return &popularityClient{cc}
}

func (c *popularityClient) GetAnchorGradeList(ctx context.Context, in *GetAnchorGradeListReq, opts ...grpc.CallOption) (*GetAnchorGradeListResp, error) {
	out := new(GetAnchorGradeListResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.Popularity/GetAnchorGradeList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *popularityClient) EditAnchorGrade(ctx context.Context, in *EditAnchorGradeReq, opts ...grpc.CallOption) (*EditAnchorGradeResp, error) {
	out := new(EditAnchorGradeResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.Popularity/EditAnchorGrade", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *popularityClient) GetContentList(ctx context.Context, in *GetContentListReq, opts ...grpc.CallOption) (*GetContentListResp, error) {
	out := new(GetContentListResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.Popularity/GetContentList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *popularityClient) AddContent(ctx context.Context, in *AddContentReq, opts ...grpc.CallOption) (*AddContentResp, error) {
	out := new(AddContentResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.Popularity/AddContent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *popularityClient) EditContent(ctx context.Context, in *EditContentReq, opts ...grpc.CallOption) (*EditContentResp, error) {
	out := new(EditContentResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.Popularity/EditContent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *popularityClient) DeleteContent(ctx context.Context, in *DeleteContentReq, opts ...grpc.CallOption) (*DeleteContentResp, error) {
	out := new(DeleteContentResp)
	err := c.cc.Invoke(ctx, "/live.daoanchor.v0.Popularity/DeleteContent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PopularityServer is the server API for Popularity service.
type PopularityServer interface {
	// GetAnchorGradeList 获取人气值主播评级列表
	GetAnchorGradeList(context.Context, *GetAnchorGradeListReq) (*GetAnchorGradeListResp, error)
	// EditAnchorGrade  编辑主播评级对应的人气值数据
	EditAnchorGrade(context.Context, *EditAnchorGradeReq) (*EditAnchorGradeResp, error)
	// GetContentList  人气内容系数列表
	GetContentList(context.Context, *GetContentListReq) (*GetContentListResp, error)
	// AddContent 添加内容系数
	AddContent(context.Context, *AddContentReq) (*AddContentResp, error)
	// EditContent 编辑内容系数
	EditContent(context.Context, *EditContentReq) (*EditContentResp, error)
	// DeleteContent 删除内容系数
	DeleteContent(context.Context, *DeleteContentReq) (*DeleteContentResp, error)
}

func RegisterPopularityServer(s *grpc.Server, srv PopularityServer) {
	s.RegisterService(&_Popularity_serviceDesc, srv)
}

func _Popularity_GetAnchorGradeList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAnchorGradeListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PopularityServer).GetAnchorGradeList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.Popularity/GetAnchorGradeList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PopularityServer).GetAnchorGradeList(ctx, req.(*GetAnchorGradeListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Popularity_EditAnchorGrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EditAnchorGradeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PopularityServer).EditAnchorGrade(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.Popularity/EditAnchorGrade",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PopularityServer).EditAnchorGrade(ctx, req.(*EditAnchorGradeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Popularity_GetContentList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetContentListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PopularityServer).GetContentList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.Popularity/GetContentList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PopularityServer).GetContentList(ctx, req.(*GetContentListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Popularity_AddContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddContentReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PopularityServer).AddContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.Popularity/AddContent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PopularityServer).AddContent(ctx, req.(*AddContentReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Popularity_EditContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EditContentReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PopularityServer).EditContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.Popularity/EditContent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PopularityServer).EditContent(ctx, req.(*EditContentReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Popularity_DeleteContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteContentReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PopularityServer).DeleteContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.daoanchor.v0.Popularity/DeleteContent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PopularityServer).DeleteContent(ctx, req.(*DeleteContentReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Popularity_serviceDesc = grpc.ServiceDesc{
	ServiceName: "live.daoanchor.v0.Popularity",
	HandlerType: (*PopularityServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAnchorGradeList",
			Handler:    _Popularity_GetAnchorGradeList_Handler,
		},
		{
			MethodName: "EditAnchorGrade",
			Handler:    _Popularity_EditAnchorGrade_Handler,
		},
		{
			MethodName: "GetContentList",
			Handler:    _Popularity_GetContentList_Handler,
		},
		{
			MethodName: "AddContent",
			Handler:    _Popularity_AddContent_Handler,
		},
		{
			MethodName: "EditContent",
			Handler:    _Popularity_EditContent_Handler,
		},
		{
			MethodName: "DeleteContent",
			Handler:    _Popularity_DeleteContent_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/live/dao-anchor/api/grpc/v0/api.proto",
}

func (m *CreateCacheListReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateCacheListReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RoomIds) > 0 {
		dAtA2 := make([]byte, len(m.RoomIds)*10)
		var j1 int
		for _, num1 := range m.RoomIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	if len(m.Content) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CreateCacheListResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateCacheListResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CreateLiveCacheListReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateLiveCacheListReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RoomIds) > 0 {
		dAtA4 := make([]byte, len(m.RoomIds)*10)
		var j3 int
		for _, num1 := range m.RoomIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j3++
			}
			dAtA4[j3] = uint8(num)
			j3++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(j3))
		i += copy(dAtA[i:], dAtA4[:j3])
	}
	if len(m.Content) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CreateLiveCacheListResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateLiveCacheListResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetContentMapReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetContentMapReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetContentMapResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetContentMapResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.List) > 0 {
		for k, _ := range m.List {
			dAtA[i] = 0xa
			i++
			v := m.List[k]
			mapSize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v))
			i = encodeVarintApi(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintApi(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintApi(dAtA, i, uint64(v))
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CreateDBDataReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateDBDataReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RoomIds) > 0 {
		dAtA6 := make([]byte, len(m.RoomIds)*10)
		var j5 int
		for _, num1 := range m.RoomIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(j5))
		i += copy(dAtA[i:], dAtA6[:j5])
	}
	if len(m.Content) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CreateDBDataResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateDBDataResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetAnchorGradeListReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetAnchorGradeListReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetAnchorGradeListResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetAnchorGradeListResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.List) > 0 {
		for _, msg := range m.List {
			dAtA[i] = 0xa
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetAnchorGradeListResp_List) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetAnchorGradeListResp_List) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GradeId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.GradeId))
	}
	if len(m.GradeName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.GradeName)))
		i += copy(dAtA[i:], m.GradeName)
	}
	if m.BaseOnline != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.BaseOnline))
	}
	if m.PopularityRate != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EditAnchorGradeReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EditAnchorGradeReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GradeId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.GradeId))
	}
	if m.OnlineBase != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.OnlineBase))
	}
	if m.PopularityRate != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EditAnchorGradeResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EditAnchorGradeResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AddAnchorGradeReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddAnchorGradeReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Id))
	}
	if m.OnlineBase != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.OnlineBase))
	}
	if m.PopularityRate != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AddAnchorGradeResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddAnchorGradeResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetContentListReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetContentListReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Page != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Page))
	}
	if m.PageSize != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PageSize))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetContentListResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetContentListResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Page != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Page))
	}
	if m.PageSize != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PageSize))
	}
	if m.TotalCount != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.TotalCount))
	}
	if len(m.List) > 0 {
		for _, msg := range m.List {
			dAtA[i] = 0x22
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetContentListResp_List) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetContentListResp_List) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ParentAreaId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ParentAreaId))
	}
	if len(m.ParentAreaName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.ParentAreaName)))
		i += copy(dAtA[i:], m.ParentAreaName)
	}
	if len(m.AreaList) > 0 {
		for k, _ := range m.AreaList {
			dAtA[i] = 0x1a
			i++
			v := m.AreaList[k]
			mapSize := 1 + sovApi(uint64(k)) + 1 + len(v) + sovApi(uint64(len(v)))
			i = encodeVarintApi(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintApi(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintApi(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.PopularityRate != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EditContentReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EditContentReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Id))
	}
	if m.PopularityRate != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PopularityRate))
	}
	if len(m.List) > 0 {
		dAtA8 := make([]byte, len(m.List)*10)
		var j7 int
		for _, num1 := range m.List {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j7))
		i += copy(dAtA[i:], dAtA8[:j7])
	}
	if m.ParentId != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ParentId))
	}
	if m.IsAll != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.IsAll))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EditContentResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EditContentResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AddContentReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddContentReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ParentId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ParentId))
	}
	if len(m.List) > 0 {
		dAtA10 := make([]byte, len(m.List)*10)
		var j9 int
		for _, num1 := range m.List {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(j9))
		i += copy(dAtA[i:], dAtA10[:j9])
	}
	if m.PopularityRate != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PopularityRate))
	}
	if m.IsAll != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.IsAll))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AddContentResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AddContentResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DeleteContentReq) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteContentReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Id))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DeleteContentResp) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeleteContentResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *CreateCacheListReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RoomIds) > 0 {
		l = 0
		for _, e := range m.RoomIds {
			l += sovApi(uint64(e))
		}
		n += 1 + sovApi(uint64(l)) + l
	}
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateCacheListResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *CreateLiveCacheListResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetContentMapReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetContentMapResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.List) > 0 {
		for k, v := range m.List {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v))
			n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *CreateDBDataResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetAnchorGradeListReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *GetAnchorGradeListResp_List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GradeId != 0 {
		n += 1 + sovApi(uint64(m.GradeId))
	}
	l = len(m.GradeName)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.BaseOnline != 0 {
		n += 1 + sovApi(uint64(m.BaseOnline))
	}
	if m.PopularityRate != 0 {
		n += 1 + sovApi(uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EditAnchorGradeReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GradeId != 0 {
		n += 1 + sovApi(uint64(m.GradeId))
	}
	if m.OnlineBase != 0 {
		n += 1 + sovApi(uint64(m.OnlineBase))
	}
	if m.PopularityRate != 0 {
		n += 1 + sovApi(uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EditAnchorGradeResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddAnchorGradeReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovApi(uint64(m.Id))
	}
	if m.OnlineBase != 0 {
		n += 1 + sovApi(uint64(m.OnlineBase))
	}
	if m.PopularityRate != 0 {
		n += 1 + sovApi(uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddAnchorGradeResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetContentListReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Page != 0 {
		n += 1 + sovApi(uint64(m.Page))
	}
	if m.PageSize != 0 {
		n += 1 + sovApi(uint64(m.PageSize))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetContentListResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Page != 0 {
		n += 1 + sovApi(uint64(m.Page))
	}
	if m.PageSize != 0 {
		n += 1 + sovApi(uint64(m.PageSize))
	}
	if m.TotalCount != 0 {
		n += 1 + sovApi(uint64(m.TotalCount))
	}
	if len(m.List) > 0 {
		for _, e := range m.List {
			l = e.Size()
			n += 1 + l + sovApi(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetContentListResp_List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParentAreaId != 0 {
		n += 1 + sovApi(uint64(m.ParentAreaId))
	}
	l = len(m.ParentAreaName)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if len(m.AreaList) > 0 {
		for k, v := range m.AreaList {
			_ = k
			_ = v
			mapEntrySize := 1 + sovApi(uint64(k)) + 1 + len(v) + sovApi(uint64(len(v)))
			n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize))
		}
	}
	if m.PopularityRate != 0 {
		n += 1 + sovApi(uint64(m.PopularityRate))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EditContentReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovApi(uint64(m.Id))
	}
	if m.PopularityRate != 0 {
		n += 1 + sovApi(uint64(m.PopularityRate))
	}
	if len(m.List) > 0 {
		l = 0
		for _, e := range m.List {
			l += sovApi(uint64(e))
		}
		n += 1 + sovApi(uint64(l)) + l
	}
	if m.ParentId != 0 {
		n += 1 + sovApi(uint64(m.ParentId))
	}
	if m.IsAll != 0 {
		n += 1 + sovApi(uint64(m.IsAll))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EditContentResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddContentReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ParentId != 0 {
		n += 1 + sovApi(uint64(m.ParentId))
	}
	if len(m.List) > 0 {
		l = 0
		for _, e := range m.List {
			l += sovApi(uint64(e))
		}
		n += 1 + sovApi(uint64(l)) + l
	}
	if m.PopularityRate != 0 {
		n += 1 + sovApi(uint64(m.PopularityRate))
	}
	if m.IsAll != 0 {
		n += 1 + sovApi(uint64(m.IsAll))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddContentResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *DeleteContentResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovApi(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CreateCacheListReq) 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 ErrIntOverflowApi
			}
			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: CreateCacheListReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateCacheListReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RoomIds = append(m.RoomIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RoomIds) == 0 {
					m.RoomIds = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RoomIds = append(m.RoomIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomIds", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateLiveCacheListReq) 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 ErrIntOverflowApi
			}
			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: CreateLiveCacheListReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateLiveCacheListReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RoomIds = append(m.RoomIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RoomIds) == 0 {
					m.RoomIds = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RoomIds = append(m.RoomIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomIds", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetContentMapResp) 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 ErrIntOverflowApi
			}
			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: GetContentMapResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetContentMapResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.List == nil {
				m.List = make(map[string]int64)
			}
			var mapkey string
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthApi
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipApi(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthApi
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.List[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateDBDataReq) 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 ErrIntOverflowApi
			}
			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: CreateDBDataReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateDBDataReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RoomIds = append(m.RoomIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RoomIds) == 0 {
					m.RoomIds = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RoomIds = append(m.RoomIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomIds", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Content = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetAnchorGradeListResp) 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 ErrIntOverflowApi
			}
			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: GetAnchorGradeListResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetAnchorGradeListResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.List = append(m.List, &GetAnchorGradeListResp_List{})
			if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetAnchorGradeListResp_List) 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 ErrIntOverflowApi
			}
			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: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GradeId", wireType)
			}
			m.GradeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GradeId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GradeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GradeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseOnline", wireType)
			}
			m.BaseOnline = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BaseOnline |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopularityRate", wireType)
			}
			m.PopularityRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopularityRate |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EditAnchorGradeReq) 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 ErrIntOverflowApi
			}
			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: EditAnchorGradeReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EditAnchorGradeReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GradeId", wireType)
			}
			m.GradeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GradeId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnlineBase", wireType)
			}
			m.OnlineBase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnlineBase |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopularityRate", wireType)
			}
			m.PopularityRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopularityRate |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddAnchorGradeReq) 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 ErrIntOverflowApi
			}
			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: AddAnchorGradeReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddAnchorGradeReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnlineBase", wireType)
			}
			m.OnlineBase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnlineBase |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopularityRate", wireType)
			}
			m.PopularityRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopularityRate |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetContentListReq) 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 ErrIntOverflowApi
			}
			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: GetContentListReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetContentListReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
			}
			m.Page = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Page |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageSize", wireType)
			}
			m.PageSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PageSize |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetContentListResp) 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 ErrIntOverflowApi
			}
			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: GetContentListResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetContentListResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
			}
			m.Page = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Page |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageSize", wireType)
			}
			m.PageSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PageSize |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalCount", wireType)
			}
			m.TotalCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalCount |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.List = append(m.List, &GetContentListResp_List{})
			if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetContentListResp_List) 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 ErrIntOverflowApi
			}
			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: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentAreaId", wireType)
			}
			m.ParentAreaId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentAreaId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentAreaName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ParentAreaName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AreaList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AreaList == nil {
				m.AreaList = make(map[int64]string)
			}
			var mapkey int64
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthApi
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipApi(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthApi
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.AreaList[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopularityRate", wireType)
			}
			m.PopularityRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopularityRate |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EditContentReq) 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 ErrIntOverflowApi
			}
			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: EditContentReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EditContentReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopularityRate", wireType)
			}
			m.PopularityRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopularityRate |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.List = append(m.List, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.List) == 0 {
					m.List = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.List = append(m.List, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentId", wireType)
			}
			m.ParentId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAll", wireType)
			}
			m.IsAll = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsAll |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddContentReq) 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 ErrIntOverflowApi
			}
			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: AddContentReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddContentReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentId", wireType)
			}
			m.ParentId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.List = append(m.List, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.List) == 0 {
					m.List = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.List = append(m.List, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopularityRate", wireType)
			}
			m.PopularityRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopularityRate |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAll", wireType)
			}
			m.IsAll = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsAll |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteContentReq) 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 ErrIntOverflowApi
			}
			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: DeleteContentReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteContentReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApi(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApi
			}
			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, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthApi
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowApi
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipApi(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApi   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("app/service/live/dao-anchor/api/grpc/v0/api.proto", fileDescriptor_api_def40e84f903f7bf)
}

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