bilibili-go-common/app/service/main/history/api/grpc/api.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/main/history/api/grpc/api.proto

/*
	Package v1 is a generated protocol buffer package.

	It is generated from these files:
		app/service/main/history/api/grpc/api.proto

	It has these top-level messages:
		AddHistoryReply
		AddHistoryReq
		AddHistoriesReq
		AddHistoriesReply
		DelHistoriesReq
		DelHistoriesReply
		ClearHistoryReq
		ClearHistoryReply
		UserHistoriesReq
		UserHistoriesReply
		HistoriesReq
		HistoriesReply
		UserHideReq
		UserHideReply
		UpdateUserHideReq
		UpdateUserHideReply
*/
package v1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import history "go-common/app/service/main/history/model"

import context "golang.org/x/net/context"
import 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

// AddHistoryReply reply
type AddHistoryReply struct {
}

func (m *AddHistoryReply) Reset()                    { *m = AddHistoryReply{} }
func (m *AddHistoryReply) String() string            { return proto.CompactTextString(m) }
func (*AddHistoryReply) ProtoMessage()               {}
func (*AddHistoryReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} }

// AddHistoryReq req
type AddHistoryReq struct {
	// mid
	Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required"`
	// business 业务
	Business string `protobuf:"bytes,2,opt,name=business,proto3" json:"business,omitempty" form:"business" validate:"required"`
	// kid 业务中唯一id
	Kid int64 `protobuf:"varint,3,opt,name=kid,proto3" json:"kid,omitempty" form:"kid" validate:"required"`
	// aid
	Aid int64 `protobuf:"varint,4,opt,name=aid,proto3" json:"aid,omitempty" form:"aid"`
	// sid
	Sid int64 `protobuf:"varint,5,opt,name=sid,proto3" json:"sid,omitempty" form:"sid"`
	// epid
	Epid int64 `protobuf:"varint,6,opt,name=epid,proto3" json:"epid,omitempty" form:"epid"`
	// cid
	Cid int64 `protobuf:"varint,7,opt,name=cid,proto3" json:"cid,omitempty" form:"cid"`
	// sub_type 子类型
	SubType int32 `protobuf:"varint,8,opt,name=sub_type,json=subType,proto3" json:"sub_type,omitempty" form:"sub_type"`
	// device 设备类型
	Device int32 `protobuf:"varint,9,opt,name=device,proto3" json:"device,omitempty" form:"device"`
	// progress 进度
	Progress int32 `protobuf:"varint,10,opt,name=progress,proto3" json:"progress,omitempty" form:"progress"`
	// 观看时间
	ViewAt int64 `protobuf:"varint,11,opt,name=view_at,json=viewAt,proto3" json:"view_at,omitempty" form:"view_at" validate:"required"`
}

func (m *AddHistoryReq) Reset()                    { *m = AddHistoryReq{} }
func (m *AddHistoryReq) String() string            { return proto.CompactTextString(m) }
func (*AddHistoryReq) ProtoMessage()               {}
func (*AddHistoryReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }

func (m *AddHistoryReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

func (m *AddHistoryReq) GetBusiness() string {
	if m != nil {
		return m.Business
	}
	return ""
}

func (m *AddHistoryReq) GetKid() int64 {
	if m != nil {
		return m.Kid
	}
	return 0
}

func (m *AddHistoryReq) GetAid() int64 {
	if m != nil {
		return m.Aid
	}
	return 0
}

func (m *AddHistoryReq) GetSid() int64 {
	if m != nil {
		return m.Sid
	}
	return 0
}

func (m *AddHistoryReq) GetEpid() int64 {
	if m != nil {
		return m.Epid
	}
	return 0
}

func (m *AddHistoryReq) GetCid() int64 {
	if m != nil {
		return m.Cid
	}
	return 0
}

func (m *AddHistoryReq) GetSubType() int32 {
	if m != nil {
		return m.SubType
	}
	return 0
}

func (m *AddHistoryReq) GetDevice() int32 {
	if m != nil {
		return m.Device
	}
	return 0
}

func (m *AddHistoryReq) GetProgress() int32 {
	if m != nil {
		return m.Progress
	}
	return 0
}

func (m *AddHistoryReq) GetViewAt() int64 {
	if m != nil {
		return m.ViewAt
	}
	return 0
}

// AddHistoriesReq 增加多条记录
type AddHistoriesReq struct {
	Histories []*AddHistoryReq `protobuf:"bytes,1,rep,name=histories" json:"histories,omitempty"`
}

func (m *AddHistoriesReq) Reset()                    { *m = AddHistoriesReq{} }
func (m *AddHistoriesReq) String() string            { return proto.CompactTextString(m) }
func (*AddHistoriesReq) ProtoMessage()               {}
func (*AddHistoriesReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2} }

func (m *AddHistoriesReq) GetHistories() []*AddHistoryReq {
	if m != nil {
		return m.Histories
	}
	return nil
}

// AddHistoriesReply .
type AddHistoriesReply struct {
}

func (m *AddHistoriesReply) Reset()                    { *m = AddHistoriesReply{} }
func (m *AddHistoriesReply) String() string            { return proto.CompactTextString(m) }
func (*AddHistoriesReply) ProtoMessage()               {}
func (*AddHistoriesReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{3} }

// DelHistoriesReq del histories request
type DelHistoriesReq struct {
	// mid
	Mid     int64                     `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required,min=1"`
	Records []*DelHistoriesReq_Record `protobuf:"bytes,2,rep,name=records" json:"records,omitempty" validate:"required"`
}

func (m *DelHistoriesReq) Reset()                    { *m = DelHistoriesReq{} }
func (m *DelHistoriesReq) String() string            { return proto.CompactTextString(m) }
func (*DelHistoriesReq) ProtoMessage()               {}
func (*DelHistoriesReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{4} }

func (m *DelHistoriesReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

func (m *DelHistoriesReq) GetRecords() []*DelHistoriesReq_Record {
	if m != nil {
		return m.Records
	}
	return nil
}

type DelHistoriesReq_Record struct {
	// business 业务
	Business string `protobuf:"bytes,1,opt,name=business,proto3" json:"business,omitempty" form:"business" validate:"required"`
	// id
	ID int64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty" form:"id" validate:"required"`
}

func (m *DelHistoriesReq_Record) Reset()                    { *m = DelHistoriesReq_Record{} }
func (m *DelHistoriesReq_Record) String() string            { return proto.CompactTextString(m) }
func (*DelHistoriesReq_Record) ProtoMessage()               {}
func (*DelHistoriesReq_Record) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{4, 0} }

func (m *DelHistoriesReq_Record) GetBusiness() string {
	if m != nil {
		return m.Business
	}
	return ""
}

func (m *DelHistoriesReq_Record) GetID() int64 {
	if m != nil {
		return m.ID
	}
	return 0
}

// DelHistoriesReply del histories reply
type DelHistoriesReply struct {
}

func (m *DelHistoriesReply) Reset()                    { *m = DelHistoriesReply{} }
func (m *DelHistoriesReply) String() string            { return proto.CompactTextString(m) }
func (*DelHistoriesReply) ProtoMessage()               {}
func (*DelHistoriesReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{5} }

// ClearHistoryReq clear histories request
type ClearHistoryReq struct {
	// businesses 业务 为空为全部业务
	Businesses []string `protobuf:"bytes,1,rep,name=businesses" json:"businesses,omitempty" form:"businesses,split"`
	// mid
	Mid int64 `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required,min=1"`
}

func (m *ClearHistoryReq) Reset()                    { *m = ClearHistoryReq{} }
func (m *ClearHistoryReq) String() string            { return proto.CompactTextString(m) }
func (*ClearHistoryReq) ProtoMessage()               {}
func (*ClearHistoryReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{6} }

func (m *ClearHistoryReq) GetBusinesses() []string {
	if m != nil {
		return m.Businesses
	}
	return nil
}

func (m *ClearHistoryReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

// ClearHistoryReply clear histories reply
type ClearHistoryReply struct {
}

func (m *ClearHistoryReply) Reset()                    { *m = ClearHistoryReply{} }
func (m *ClearHistoryReply) String() string            { return proto.CompactTextString(m) }
func (*ClearHistoryReply) ProtoMessage()               {}
func (*ClearHistoryReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{7} }

// UserHistoriesReq .
type UserHistoriesReq struct {
	// mid
	Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required,min=1"`
	// businesses 查询的业务范围 为空为全部业务
	Businesses []string `protobuf:"bytes,2,rep,name=businesses" json:"businesses,omitempty" form:"businesses,split"`
	// business 上一条的业务类型
	Business string `protobuf:"bytes,3,opt,name=business,proto3" json:"business,omitempty" form:"business"`
	// kid 上一条的id 业务中唯一id
	Kid int64 `protobuf:"varint,4,opt,name=kid,proto3" json:"kid,omitempty" form:"kid"`
	// 上一条的观看时间
	ViewAt int64 `protobuf:"varint,5,opt,name=view_at,json=viewAt,proto3" json:"view_at,omitempty" form:"view_at" validate:"required"`
	// 每页几条
	Ps int64 `protobuf:"varint,6,opt,name=Ps,proto3" json:"Ps,omitempty" form:"ps" validate:"required,min=1,max=1000"`
}

func (m *UserHistoriesReq) Reset()                    { *m = UserHistoriesReq{} }
func (m *UserHistoriesReq) String() string            { return proto.CompactTextString(m) }
func (*UserHistoriesReq) ProtoMessage()               {}
func (*UserHistoriesReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{8} }

func (m *UserHistoriesReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

func (m *UserHistoriesReq) GetBusinesses() []string {
	if m != nil {
		return m.Businesses
	}
	return nil
}

func (m *UserHistoriesReq) GetBusiness() string {
	if m != nil {
		return m.Business
	}
	return ""
}

func (m *UserHistoriesReq) GetKid() int64 {
	if m != nil {
		return m.Kid
	}
	return 0
}

func (m *UserHistoriesReq) GetViewAt() int64 {
	if m != nil {
		return m.ViewAt
	}
	return 0
}

func (m *UserHistoriesReq) GetPs() int64 {
	if m != nil {
		return m.Ps
	}
	return 0
}

// UserHistoriesReply .
type UserHistoriesReply struct {
	Histories []*history.History `protobuf:"bytes,1,rep,name=histories" json:"histories"`
}

func (m *UserHistoriesReply) Reset()                    { *m = UserHistoriesReply{} }
func (m *UserHistoriesReply) String() string            { return proto.CompactTextString(m) }
func (*UserHistoriesReply) ProtoMessage()               {}
func (*UserHistoriesReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{9} }

func (m *UserHistoriesReply) GetHistories() []*history.History {
	if m != nil {
		return m.Histories
	}
	return nil
}

// HistoriesReq .
type HistoriesReq struct {
	// mid
	Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required,min=1"`
	// business 业务
	Business string `protobuf:"bytes,2,opt,name=business,proto3" json:"business,omitempty" form:"business" validate:"required"`
	// kids 业务id
	Kids []int64 `protobuf:"varint,3,rep,packed,name=kids" json:"kids,omitempty" form:"kids,split" validate:"required"`
}

func (m *HistoriesReq) Reset()                    { *m = HistoriesReq{} }
func (m *HistoriesReq) String() string            { return proto.CompactTextString(m) }
func (*HistoriesReq) ProtoMessage()               {}
func (*HistoriesReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{10} }

func (m *HistoriesReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

func (m *HistoriesReq) GetBusiness() string {
	if m != nil {
		return m.Business
	}
	return ""
}

func (m *HistoriesReq) GetKids() []int64 {
	if m != nil {
		return m.Kids
	}
	return nil
}

// AddHistoriesReply .
type HistoriesReply struct {
	Histories map[int64]*history.History `protobuf:"bytes,1,rep,name=histories" json:"histories" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *HistoriesReply) Reset()                    { *m = HistoriesReply{} }
func (m *HistoriesReply) String() string            { return proto.CompactTextString(m) }
func (*HistoriesReply) ProtoMessage()               {}
func (*HistoriesReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{11} }

func (m *HistoriesReply) GetHistories() map[int64]*history.History {
	if m != nil {
		return m.Histories
	}
	return nil
}

// UserHideReq req
type UserHideReq struct {
	// mid
	Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required,min=1"`
}

func (m *UserHideReq) Reset()                    { *m = UserHideReq{} }
func (m *UserHideReq) String() string            { return proto.CompactTextString(m) }
func (*UserHideReq) ProtoMessage()               {}
func (*UserHideReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{12} }

func (m *UserHideReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

// UserHideReply reply
type UserHideReply struct {
	Hide bool `protobuf:"varint,1,opt,name=hide,proto3" json:"hide"`
}

func (m *UserHideReply) Reset()                    { *m = UserHideReply{} }
func (m *UserHideReply) String() string            { return proto.CompactTextString(m) }
func (*UserHideReply) ProtoMessage()               {}
func (*UserHideReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{13} }

func (m *UserHideReply) GetHide() bool {
	if m != nil {
		return m.Hide
	}
	return false
}

// UpdateUserHideReq req
type UpdateUserHideReq struct {
	// mid
	Mid  int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty" form:"mid" validate:"required,min=1"`
	Hide bool  `protobuf:"varint,2,opt,name=hide,proto3" json:"hide,omitempty" form:"hide"`
}

func (m *UpdateUserHideReq) Reset()                    { *m = UpdateUserHideReq{} }
func (m *UpdateUserHideReq) String() string            { return proto.CompactTextString(m) }
func (*UpdateUserHideReq) ProtoMessage()               {}
func (*UpdateUserHideReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{14} }

func (m *UpdateUserHideReq) GetMid() int64 {
	if m != nil {
		return m.Mid
	}
	return 0
}

func (m *UpdateUserHideReq) GetHide() bool {
	if m != nil {
		return m.Hide
	}
	return false
}

// UpdateUserHideReply reply
type UpdateUserHideReply struct {
}

func (m *UpdateUserHideReply) Reset()                    { *m = UpdateUserHideReply{} }
func (m *UpdateUserHideReply) String() string            { return proto.CompactTextString(m) }
func (*UpdateUserHideReply) ProtoMessage()               {}
func (*UpdateUserHideReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{15} }

func init() {
	proto.RegisterType((*AddHistoryReply)(nil), "community.service.history.v1.AddHistoryReply")
	proto.RegisterType((*AddHistoryReq)(nil), "community.service.history.v1.AddHistoryReq")
	proto.RegisterType((*AddHistoriesReq)(nil), "community.service.history.v1.AddHistoriesReq")
	proto.RegisterType((*AddHistoriesReply)(nil), "community.service.history.v1.AddHistoriesReply")
	proto.RegisterType((*DelHistoriesReq)(nil), "community.service.history.v1.DelHistoriesReq")
	proto.RegisterType((*DelHistoriesReq_Record)(nil), "community.service.history.v1.DelHistoriesReq.Record")
	proto.RegisterType((*DelHistoriesReply)(nil), "community.service.history.v1.DelHistoriesReply")
	proto.RegisterType((*ClearHistoryReq)(nil), "community.service.history.v1.ClearHistoryReq")
	proto.RegisterType((*ClearHistoryReply)(nil), "community.service.history.v1.ClearHistoryReply")
	proto.RegisterType((*UserHistoriesReq)(nil), "community.service.history.v1.UserHistoriesReq")
	proto.RegisterType((*UserHistoriesReply)(nil), "community.service.history.v1.UserHistoriesReply")
	proto.RegisterType((*HistoriesReq)(nil), "community.service.history.v1.HistoriesReq")
	proto.RegisterType((*HistoriesReply)(nil), "community.service.history.v1.HistoriesReply")
	proto.RegisterType((*UserHideReq)(nil), "community.service.history.v1.UserHideReq")
	proto.RegisterType((*UserHideReply)(nil), "community.service.history.v1.UserHideReply")
	proto.RegisterType((*UpdateUserHideReq)(nil), "community.service.history.v1.UpdateUserHideReq")
	proto.RegisterType((*UpdateUserHideReply)(nil), "community.service.history.v1.UpdateUserHideReply")
}

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

// Client API for History service

type HistoryClient interface {
	// AddHistory add history. 增加播放历史接口
	AddHistory(ctx context.Context, in *AddHistoryReq, opts ...grpc.CallOption) (*AddHistoryReply, error)
	// AddHistories 增加多条播放历史记录
	AddHistories(ctx context.Context, in *AddHistoriesReq, opts ...grpc.CallOption) (*AddHistoriesReply, error)
	// DelHistories delete histories. 批量删除播放历史接口
	DelHistories(ctx context.Context, in *DelHistoriesReq, opts ...grpc.CallOption) (*DelHistoriesReply, error)
	// ClearHistory clear history 按照业务删除所有播放记录
	ClearHistory(ctx context.Context, in *ClearHistoryReq, opts ...grpc.CallOption) (*ClearHistoryReply, error)
	// UserHistories 查询用户的播放历史列表
	UserHistories(ctx context.Context, in *UserHistoriesReq, opts ...grpc.CallOption) (*UserHistoriesReply, error)
	// Histories 根据id查询播放历史
	Histories(ctx context.Context, in *HistoriesReq, opts ...grpc.CallOption) (*HistoriesReply, error)
	// UserHide 查询是否记录播放历史
	UserHide(ctx context.Context, in *UserHideReq, opts ...grpc.CallOption) (*UserHideReply, error)
	// UpdateUserHide 修改是否记录播放历史
	UpdateUserHide(ctx context.Context, in *UpdateUserHideReq, opts ...grpc.CallOption) (*UpdateUserHideReply, error)
}

type historyClient struct {
	cc *grpc.ClientConn
}

func NewHistoryClient(cc *grpc.ClientConn) HistoryClient {
	return &historyClient{cc}
}

func (c *historyClient) AddHistory(ctx context.Context, in *AddHistoryReq, opts ...grpc.CallOption) (*AddHistoryReply, error) {
	out := new(AddHistoryReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/AddHistory", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) AddHistories(ctx context.Context, in *AddHistoriesReq, opts ...grpc.CallOption) (*AddHistoriesReply, error) {
	out := new(AddHistoriesReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/AddHistories", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) DelHistories(ctx context.Context, in *DelHistoriesReq, opts ...grpc.CallOption) (*DelHistoriesReply, error) {
	out := new(DelHistoriesReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/DelHistories", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) ClearHistory(ctx context.Context, in *ClearHistoryReq, opts ...grpc.CallOption) (*ClearHistoryReply, error) {
	out := new(ClearHistoryReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/ClearHistory", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) UserHistories(ctx context.Context, in *UserHistoriesReq, opts ...grpc.CallOption) (*UserHistoriesReply, error) {
	out := new(UserHistoriesReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/UserHistories", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) Histories(ctx context.Context, in *HistoriesReq, opts ...grpc.CallOption) (*HistoriesReply, error) {
	out := new(HistoriesReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/Histories", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) UserHide(ctx context.Context, in *UserHideReq, opts ...grpc.CallOption) (*UserHideReply, error) {
	out := new(UserHideReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/UserHide", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *historyClient) UpdateUserHide(ctx context.Context, in *UpdateUserHideReq, opts ...grpc.CallOption) (*UpdateUserHideReply, error) {
	out := new(UpdateUserHideReply)
	err := grpc.Invoke(ctx, "/community.service.history.v1.History/UpdateUserHide", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for History service

type HistoryServer interface {
	// AddHistory add history. 增加播放历史接口
	AddHistory(context.Context, *AddHistoryReq) (*AddHistoryReply, error)
	// AddHistories 增加多条播放历史记录
	AddHistories(context.Context, *AddHistoriesReq) (*AddHistoriesReply, error)
	// DelHistories delete histories. 批量删除播放历史接口
	DelHistories(context.Context, *DelHistoriesReq) (*DelHistoriesReply, error)
	// ClearHistory clear history 按照业务删除所有播放记录
	ClearHistory(context.Context, *ClearHistoryReq) (*ClearHistoryReply, error)
	// UserHistories 查询用户的播放历史列表
	UserHistories(context.Context, *UserHistoriesReq) (*UserHistoriesReply, error)
	// Histories 根据id查询播放历史
	Histories(context.Context, *HistoriesReq) (*HistoriesReply, error)
	// UserHide 查询是否记录播放历史
	UserHide(context.Context, *UserHideReq) (*UserHideReply, error)
	// UpdateUserHide 修改是否记录播放历史
	UpdateUserHide(context.Context, *UpdateUserHideReq) (*UpdateUserHideReply, error)
}

func RegisterHistoryServer(s *grpc.Server, srv HistoryServer) {
	s.RegisterService(&_History_serviceDesc, srv)
}

func _History_AddHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddHistoryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).AddHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/AddHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).AddHistory(ctx, req.(*AddHistoryReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_AddHistories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddHistoriesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).AddHistories(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/AddHistories",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).AddHistories(ctx, req.(*AddHistoriesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_DelHistories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelHistoriesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).DelHistories(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/DelHistories",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).DelHistories(ctx, req.(*DelHistoriesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_ClearHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearHistoryReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).ClearHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/ClearHistory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).ClearHistory(ctx, req.(*ClearHistoryReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_UserHistories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserHistoriesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).UserHistories(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/UserHistories",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).UserHistories(ctx, req.(*UserHistoriesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_Histories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HistoriesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).Histories(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/Histories",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).Histories(ctx, req.(*HistoriesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_UserHide_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserHideReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).UserHide(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/UserHide",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).UserHide(ctx, req.(*UserHideReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _History_UpdateUserHide_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateUserHideReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HistoryServer).UpdateUserHide(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.history.v1.History/UpdateUserHide",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HistoryServer).UpdateUserHide(ctx, req.(*UpdateUserHideReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _History_serviceDesc = grpc.ServiceDesc{
	ServiceName: "community.service.history.v1.History",
	HandlerType: (*HistoryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddHistory",
			Handler:    _History_AddHistory_Handler,
		},
		{
			MethodName: "AddHistories",
			Handler:    _History_AddHistories_Handler,
		},
		{
			MethodName: "DelHistories",
			Handler:    _History_DelHistories_Handler,
		},
		{
			MethodName: "ClearHistory",
			Handler:    _History_ClearHistory_Handler,
		},
		{
			MethodName: "UserHistories",
			Handler:    _History_UserHistories_Handler,
		},
		{
			MethodName: "Histories",
			Handler:    _History_Histories_Handler,
		},
		{
			MethodName: "UserHide",
			Handler:    _History_UserHide_Handler,
		},
		{
			MethodName: "UpdateUserHide",
			Handler:    _History_UpdateUserHide_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/main/history/api/grpc/api.proto",
}

func (m *AddHistoryReply) 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 *AddHistoryReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *AddHistoryReq) 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 *AddHistoryReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Business) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Business)))
		i += copy(dAtA[i:], m.Business)
	}
	if m.Kid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Kid))
	}
	if m.Aid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Aid))
	}
	if m.Sid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Sid))
	}
	if m.Epid != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Epid))
	}
	if m.Cid != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Cid))
	}
	if m.SubType != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.SubType))
	}
	if m.Device != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Device))
	}
	if m.Progress != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Progress))
	}
	if m.ViewAt != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ViewAt))
	}
	return i, nil
}

func (m *AddHistoriesReq) 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 *AddHistoriesReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Histories) > 0 {
		for _, msg := range m.Histories {
			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
		}
	}
	return i, nil
}

func (m *AddHistoriesReply) 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 *AddHistoriesReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *DelHistoriesReq) 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 *DelHistoriesReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Records) > 0 {
		for _, msg := range m.Records {
			dAtA[i] = 0x12
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *DelHistoriesReq_Record) 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 *DelHistoriesReq_Record) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Business) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Business)))
		i += copy(dAtA[i:], m.Business)
	}
	if m.ID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ID))
	}
	return i, nil
}

func (m *DelHistoriesReply) 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 *DelHistoriesReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ClearHistoryReq) 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 *ClearHistoryReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Businesses) > 0 {
		for _, s := range m.Businesses {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	return i, nil
}

func (m *ClearHistoryReply) 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 *ClearHistoryReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *UserHistoriesReq) 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 *UserHistoriesReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Businesses) > 0 {
		for _, s := range m.Businesses {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.Business) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Business)))
		i += copy(dAtA[i:], m.Business)
	}
	if m.Kid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Kid))
	}
	if m.ViewAt != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ViewAt))
	}
	if m.Ps != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ps))
	}
	return i, nil
}

func (m *UserHistoriesReply) 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 *UserHistoriesReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Histories) > 0 {
		for _, msg := range m.Histories {
			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
		}
	}
	return i, nil
}

func (m *HistoriesReq) 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 *HistoriesReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Business) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Business)))
		i += copy(dAtA[i:], m.Business)
	}
	if len(m.Kids) > 0 {
		dAtA2 := make([]byte, len(m.Kids)*10)
		var j1 int
		for _, num1 := range m.Kids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	return i, nil
}

func (m *HistoriesReply) 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 *HistoriesReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Histories) > 0 {
		for k, _ := range m.Histories {
			dAtA[i] = 0xa
			i++
			v := m.Histories[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovApi(uint64(msgSize))
			}
			mapSize := 1 + sovApi(uint64(k)) + msgSize
			i = encodeVarintApi(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintApi(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintApi(dAtA, i, uint64(v.Size()))
				n3, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n3
			}
		}
	}
	return i, nil
}

func (m *UserHideReq) 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 *UserHideReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	return i, nil
}

func (m *UserHideReply) 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 *UserHideReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Hide {
		dAtA[i] = 0x8
		i++
		if m.Hide {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *UpdateUserHideReq) 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 *UpdateUserHideReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Hide {
		dAtA[i] = 0x10
		i++
		if m.Hide {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *UpdateUserHideReply) 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 *UpdateUserHideReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	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 *AddHistoryReply) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *AddHistoryReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Business)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Kid != 0 {
		n += 1 + sovApi(uint64(m.Kid))
	}
	if m.Aid != 0 {
		n += 1 + sovApi(uint64(m.Aid))
	}
	if m.Sid != 0 {
		n += 1 + sovApi(uint64(m.Sid))
	}
	if m.Epid != 0 {
		n += 1 + sovApi(uint64(m.Epid))
	}
	if m.Cid != 0 {
		n += 1 + sovApi(uint64(m.Cid))
	}
	if m.SubType != 0 {
		n += 1 + sovApi(uint64(m.SubType))
	}
	if m.Device != 0 {
		n += 1 + sovApi(uint64(m.Device))
	}
	if m.Progress != 0 {
		n += 1 + sovApi(uint64(m.Progress))
	}
	if m.ViewAt != 0 {
		n += 1 + sovApi(uint64(m.ViewAt))
	}
	return n
}

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

func (m *AddHistoriesReply) Size() (n int) {
	var l int
	_ = l
	return n
}

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

func (m *DelHistoriesReq_Record) Size() (n int) {
	var l int
	_ = l
	l = len(m.Business)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.ID != 0 {
		n += 1 + sovApi(uint64(m.ID))
	}
	return n
}

func (m *DelHistoriesReply) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ClearHistoryReq) Size() (n int) {
	var l int
	_ = l
	if len(m.Businesses) > 0 {
		for _, s := range m.Businesses {
			l = len(s)
			n += 1 + l + sovApi(uint64(l))
		}
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	return n
}

func (m *ClearHistoryReply) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *UserHistoriesReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if len(m.Businesses) > 0 {
		for _, s := range m.Businesses {
			l = len(s)
			n += 1 + l + sovApi(uint64(l))
		}
	}
	l = len(m.Business)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Kid != 0 {
		n += 1 + sovApi(uint64(m.Kid))
	}
	if m.ViewAt != 0 {
		n += 1 + sovApi(uint64(m.ViewAt))
	}
	if m.Ps != 0 {
		n += 1 + sovApi(uint64(m.Ps))
	}
	return n
}

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

func (m *HistoriesReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Business)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if len(m.Kids) > 0 {
		l = 0
		for _, e := range m.Kids {
			l += sovApi(uint64(e))
		}
		n += 1 + sovApi(uint64(l)) + l
	}
	return n
}

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

func (m *UserHideReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	return n
}

func (m *UserHideReply) Size() (n int) {
	var l int
	_ = l
	if m.Hide {
		n += 2
	}
	return n
}

func (m *UpdateUserHideReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Hide {
		n += 2
	}
	return n
}

func (m *UpdateUserHideReply) Size() (n int) {
	var l int
	_ = l
	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 *AddHistoryReply) 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: AddHistoryReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddHistoryReply: 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
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddHistoryReq) 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: AddHistoryReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddHistoryReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Business", 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.Business = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kid", wireType)
			}
			m.Kid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Kid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Aid", wireType)
			}
			m.Aid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Aid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sid", wireType)
			}
			m.Sid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epid", wireType)
			}
			m.Epid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
			}
			m.Cid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubType", wireType)
			}
			m.SubType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
			}
			m.Device = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Device |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType)
			}
			m.Progress = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Progress |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewAt", wireType)
			}
			m.ViewAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ViewAt |= (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
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddHistoriesReq) 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: AddHistoriesReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddHistoriesReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Histories", 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.Histories = append(m.Histories, &AddHistoryReq{})
			if err := m.Histories[len(m.Histories)-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
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClearHistoryReq) 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: ClearHistoryReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClearHistoryReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Businesses", 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.Businesses = append(m.Businesses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (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
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UserHistoriesReq) 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: UserHistoriesReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserHistoriesReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Businesses", 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.Businesses = append(m.Businesses, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Business", 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.Business = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kid", wireType)
			}
			m.Kid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Kid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewAt", wireType)
			}
			m.ViewAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ViewAt |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ps", wireType)
			}
			m.Ps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ps |= (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
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UserHistoriesReply) 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: UserHistoriesReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserHistoriesReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Histories", 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.Histories = append(m.Histories, &history.History{})
			if err := m.Histories[len(m.Histories)-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
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HistoriesReply) 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: HistoriesReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HistoriesReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Histories", 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.Histories == nil {
				m.Histories = make(map[int64]*history.History)
			}
			var mapkey int64
			var mapvalue *history.History
			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 mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthApi
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthApi
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &history.History{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} 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.Histories[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
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UserHideReq) 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: UserHideReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserHideReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (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
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UpdateUserHideReq) 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: UpdateUserHideReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateUserHideReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hide", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hide = bool(v != 0)
		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
			}
			iNdEx += skippy
		}
	}

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

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