openbilibili/app/service/main/spy/api/api.pb.go

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

package v1

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

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 ClearReliveTimesReply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ClearReliveTimesReply proto.InternalMessageInfo

type ClearReliveTimesReq struct {
	Arg                  *ModelArgReset `protobuf:"bytes,1,opt,name=arg" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_ClearReliveTimesReq proto.InternalMessageInfo

func (m *ClearReliveTimesReq) GetArg() *ModelArgReset {
	if m != nil {
		return m.Arg
	}
	return nil
}

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

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

var xxx_messageInfo_HandleEventReply proto.InternalMessageInfo

type HandleEventReq struct {
	EventMsg             *ModelEventMessage `protobuf:"bytes,1,opt,name=event_msg,json=eventMsg" json:"event_msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_HandleEventReq proto.InternalMessageInfo

func (m *HandleEventReq) GetEventMsg() *ModelEventMessage {
	if m != nil {
		return m.EventMsg
	}
	return nil
}

type ModelArgReset struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	ReLiveTime           bool     `protobuf:"varint,2,opt,name=re_live_time,json=reLiveTime,proto3" json:"re_live_time,omitempty"`
	EventScore           bool     `protobuf:"varint,3,opt,name=event_score,json=eventScore,proto3" json:"event_score,omitempty"`
	BaseScore            bool     `protobuf:"varint,4,opt,name=base_score,json=baseScore,proto3" json:"base_score,omitempty"`
	Operator             string   `protobuf:"bytes,5,opt,name=operator,proto3" json:"operator,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelArgReset proto.InternalMessageInfo

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

func (m *ModelArgReset) GetReLiveTime() bool {
	if m != nil {
		return m.ReLiveTime
	}
	return false
}

func (m *ModelArgReset) GetEventScore() bool {
	if m != nil {
		return m.EventScore
	}
	return false
}

func (m *ModelArgReset) GetBaseScore() bool {
	if m != nil {
		return m.BaseScore
	}
	return false
}

func (m *ModelArgReset) GetOperator() string {
	if m != nil {
		return m.Operator
	}
	return ""
}

type ModelEventMessage struct {
	Time      int64  `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"`
	Ip        string `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
	Service   string `protobuf:"bytes,3,opt,name=service,proto3" json:"service,omitempty"`
	Event     string `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
	ActiveMid int64  `protobuf:"varint,5,opt,name=active_mid,json=activeMid,proto3" json:"active_mid,omitempty"`
	TargetMid int64  `protobuf:"varint,6,opt,name=target_mid,json=targetMid,proto3" json:"target_mid,omitempty"`
	TargetId  int64  `protobuf:"varint,7,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"`
	// FIXME type model. args = 8;
	Result               string   `protobuf:"bytes,9,opt,name=result,proto3" json:"result,omitempty"`
	Effect               string   `protobuf:"bytes,10,opt,name=effect,proto3" json:"effect,omitempty"`
	RiskLevel            int32    `protobuf:"varint,11,opt,name=risk_level,json=riskLevel,proto3" json:"risk_level,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelEventMessage proto.InternalMessageInfo

func (m *ModelEventMessage) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *ModelEventMessage) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *ModelEventMessage) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *ModelEventMessage) GetEvent() string {
	if m != nil {
		return m.Event
	}
	return ""
}

func (m *ModelEventMessage) GetActiveMid() int64 {
	if m != nil {
		return m.ActiveMid
	}
	return 0
}

func (m *ModelEventMessage) GetTargetMid() int64 {
	if m != nil {
		return m.TargetMid
	}
	return 0
}

func (m *ModelEventMessage) GetTargetId() int64 {
	if m != nil {
		return m.TargetId
	}
	return 0
}

func (m *ModelEventMessage) GetResult() string {
	if m != nil {
		return m.Result
	}
	return ""
}

func (m *ModelEventMessage) GetEffect() string {
	if m != nil {
		return m.Effect
	}
	return ""
}

func (m *ModelEventMessage) GetRiskLevel() int32 {
	if m != nil {
		return m.RiskLevel
	}
	return 0
}

type ModelStatistics struct {
	Quantity             int64    `protobuf:"varint,1,opt,name=quantity,proto3" json:"quantity,omitempty"`
	EventId              int64    `protobuf:"varint,2,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	EventName            string   `protobuf:"bytes,3,opt,name=event_name,json=eventName,proto3" json:"event_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelStatistics proto.InternalMessageInfo

func (m *ModelStatistics) GetQuantity() int64 {
	if m != nil {
		return m.Quantity
	}
	return 0
}

func (m *ModelStatistics) GetEventId() int64 {
	if m != nil {
		return m.EventId
	}
	return 0
}

func (m *ModelStatistics) GetEventName() string {
	if m != nil {
		return m.EventName
	}
	return ""
}

type ModelUserInfo struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Score                int32    `protobuf:"varint,3,opt,name=score,proto3" json:"score,omitempty"`
	BaseScore            int32    `protobuf:"varint,4,opt,name=base_score,json=baseScore,proto3" json:"base_score,omitempty"`
	EventScore           int32    `protobuf:"varint,5,opt,name=event_score,json=eventScore,proto3" json:"event_score,omitempty"`
	State                int32    `protobuf:"varint,6,opt,name=state,proto3" json:"state,omitempty"`
	ReliveTimes          int32    `protobuf:"varint,7,opt,name=relive_times,json=reliveTimes,proto3" json:"relive_times,omitempty"`
	Ctime                int64    `protobuf:"varint,8,opt,name=ctime,proto3" json:"ctime,omitempty"`
	Mtime                int64    `protobuf:"varint,9,opt,name=mtime,proto3" json:"mtime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelUserInfo proto.InternalMessageInfo

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

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

func (m *ModelUserInfo) GetScore() int32 {
	if m != nil {
		return m.Score
	}
	return 0
}

func (m *ModelUserInfo) GetBaseScore() int32 {
	if m != nil {
		return m.BaseScore
	}
	return 0
}

func (m *ModelUserInfo) GetEventScore() int32 {
	if m != nil {
		return m.EventScore
	}
	return 0
}

func (m *ModelUserInfo) GetState() int32 {
	if m != nil {
		return m.State
	}
	return 0
}

func (m *ModelUserInfo) GetReliveTimes() int32 {
	if m != nil {
		return m.ReliveTimes
	}
	return 0
}

func (m *ModelUserInfo) GetCtime() int64 {
	if m != nil {
		return m.Ctime
	}
	return 0
}

func (m *ModelUserInfo) GetMtime() int64 {
	if m != nil {
		return m.Mtime
	}
	return 0
}

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

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

var xxx_messageInfo_PingReply proto.InternalMessageInfo

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

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

var xxx_messageInfo_PingReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_PurgeUserReply proto.InternalMessageInfo

type PurgeUserReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Action               string   `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PurgeUserReq proto.InternalMessageInfo

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

func (m *PurgeUserReq) GetAction() string {
	if m != nil {
		return m.Action
	}
	return ""
}

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

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

var xxx_messageInfo_ReBuildPortraitReply proto.InternalMessageInfo

type ReBuildPortraitReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Reason               string   `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ReBuildPortraitReq proto.InternalMessageInfo

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

func (m *ReBuildPortraitReq) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

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

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

var xxx_messageInfo_RefreshBaseScoreReply proto.InternalMessageInfo

type RefreshBaseScoreReq struct {
	Arg                  *ModelArgReset `protobuf:"bytes,1,opt,name=arg" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_RefreshBaseScoreReq proto.InternalMessageInfo

func (m *RefreshBaseScoreReq) GetArg() *ModelArgReset {
	if m != nil {
		return m.Arg
	}
	return nil
}

type StatByIDGroupEventReply struct {
	Res                  []*ModelStatistics `protobuf:"bytes,1,rep,name=res" json:"res,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_StatByIDGroupEventReply proto.InternalMessageInfo

func (m *StatByIDGroupEventReply) GetRes() []*ModelStatistics {
	if m != nil {
		return m.Res
	}
	return nil
}

type StatByIDGroupEventReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Id                   int64    `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StatByIDGroupEventReq proto.InternalMessageInfo

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

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

type StatByIDReply struct {
	Stat                 []*ModelStatistics `protobuf:"bytes,1,rep,name=stat" json:"stat,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_StatByIDReply proto.InternalMessageInfo

func (m *StatByIDReply) GetStat() []*ModelStatistics {
	if m != nil {
		return m.Stat
	}
	return nil
}

type StatByIDReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Id                   int64    `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StatByIDReq proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_UpdateBaseScoreReply proto.InternalMessageInfo

type UpdateBaseScoreReq struct {
	Arg                  *ModelArgReset `protobuf:"bytes,1,opt,name=arg" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_UpdateBaseScoreReq proto.InternalMessageInfo

func (m *UpdateBaseScoreReq) GetArg() *ModelArgReset {
	if m != nil {
		return m.Arg
	}
	return nil
}

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

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

var xxx_messageInfo_UpdateEventScoreReply proto.InternalMessageInfo

type UpdateEventScoreReq struct {
	Arg                  *ModelArgReset `protobuf:"bytes,1,opt,name=arg" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_UpdateEventScoreReq proto.InternalMessageInfo

func (m *UpdateEventScoreReq) GetArg() *ModelArgReset {
	if m != nil {
		return m.Arg
	}
	return nil
}

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

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

var xxx_messageInfo_UpdateUserScoreReply proto.InternalMessageInfo

type UpdateUserScoreReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Ip                   string   `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
	Effect               string   `protobuf:"bytes,3,opt,name=effect,proto3" json:"effect,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdateUserScoreReq proto.InternalMessageInfo

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

func (m *UpdateUserScoreReq) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *UpdateUserScoreReq) GetEffect() string {
	if m != nil {
		return m.Effect
	}
	return ""
}

type UserInfoAsynReply struct {
	Ui                   *ModelUserInfo `protobuf:"bytes,1,opt,name=ui" json:"ui,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_UserInfoAsynReply proto.InternalMessageInfo

func (m *UserInfoAsynReply) GetUi() *ModelUserInfo {
	if m != nil {
		return m.Ui
	}
	return nil
}

type UserInfoAsynReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UserInfoAsynReq proto.InternalMessageInfo

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

type UserInfoReply struct {
	Ui                   *ModelUserInfo `protobuf:"bytes,1,opt,name=ui" json:"ui,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_UserInfoReply proto.InternalMessageInfo

func (m *UserInfoReply) GetUi() *ModelUserInfo {
	if m != nil {
		return m.Ui
	}
	return nil
}

type UserInfoReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Ip                   string   `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UserInfoReq proto.InternalMessageInfo

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

func (m *UserInfoReq) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

type InfoReq struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InfoReq proto.InternalMessageInfo

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

type InfoReply struct {
	Ui                   *ModelUserInfo `protobuf:"bytes,1,opt,name=ui" json:"ui,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_InfoReply proto.InternalMessageInfo

func (m *InfoReply) GetUi() *ModelUserInfo {
	if m != nil {
		return m.Ui
	}
	return nil
}

func init() {
	proto.RegisterType((*ClearReliveTimesReply)(nil), "account.spy.ClearReliveTimesReply")
	proto.RegisterType((*ClearReliveTimesReq)(nil), "account.spy.ClearReliveTimesReq")
	proto.RegisterType((*HandleEventReply)(nil), "account.spy.HandleEventReply")
	proto.RegisterType((*HandleEventReq)(nil), "account.spy.HandleEventReq")
	proto.RegisterType((*ModelArgReset)(nil), "account.spy.ModelArgReset")
	proto.RegisterType((*ModelEventMessage)(nil), "account.spy.ModelEventMessage")
	proto.RegisterType((*ModelStatistics)(nil), "account.spy.ModelStatistics")
	proto.RegisterType((*ModelUserInfo)(nil), "account.spy.ModelUserInfo")
	proto.RegisterType((*PingReply)(nil), "account.spy.PingReply")
	proto.RegisterType((*PingReq)(nil), "account.spy.PingReq")
	proto.RegisterType((*PurgeUserReply)(nil), "account.spy.PurgeUserReply")
	proto.RegisterType((*PurgeUserReq)(nil), "account.spy.PurgeUserReq")
	proto.RegisterType((*ReBuildPortraitReply)(nil), "account.spy.ReBuildPortraitReply")
	proto.RegisterType((*ReBuildPortraitReq)(nil), "account.spy.ReBuildPortraitReq")
	proto.RegisterType((*RefreshBaseScoreReply)(nil), "account.spy.RefreshBaseScoreReply")
	proto.RegisterType((*RefreshBaseScoreReq)(nil), "account.spy.RefreshBaseScoreReq")
	proto.RegisterType((*StatByIDGroupEventReply)(nil), "account.spy.StatByIDGroupEventReply")
	proto.RegisterType((*StatByIDGroupEventReq)(nil), "account.spy.StatByIDGroupEventReq")
	proto.RegisterType((*StatByIDReply)(nil), "account.spy.StatByIDReply")
	proto.RegisterType((*StatByIDReq)(nil), "account.spy.StatByIDReq")
	proto.RegisterType((*UpdateBaseScoreReply)(nil), "account.spy.UpdateBaseScoreReply")
	proto.RegisterType((*UpdateBaseScoreReq)(nil), "account.spy.UpdateBaseScoreReq")
	proto.RegisterType((*UpdateEventScoreReply)(nil), "account.spy.UpdateEventScoreReply")
	proto.RegisterType((*UpdateEventScoreReq)(nil), "account.spy.UpdateEventScoreReq")
	proto.RegisterType((*UpdateUserScoreReply)(nil), "account.spy.UpdateUserScoreReply")
	proto.RegisterType((*UpdateUserScoreReq)(nil), "account.spy.UpdateUserScoreReq")
	proto.RegisterType((*UserInfoAsynReply)(nil), "account.spy.UserInfoAsynReply")
	proto.RegisterType((*UserInfoAsynReq)(nil), "account.spy.UserInfoAsynReq")
	proto.RegisterType((*UserInfoReply)(nil), "account.spy.UserInfoReply")
	proto.RegisterType((*UserInfoReq)(nil), "account.spy.UserInfoReq")
	proto.RegisterType((*InfoReq)(nil), "account.spy.InfoReq")
	proto.RegisterType((*InfoReply)(nil), "account.spy.InfoReply")
}

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

// SpyClient is the client API for Spy service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SpyClient interface {
	// Ping check dao health.
	Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingReply, error)
	// Info get user info by mid.
	Info(ctx context.Context, in *InfoReq, opts ...grpc.CallOption) (*InfoReply, error)
	// StatByID spy stat by id or mid.
	StatByID(ctx context.Context, in *StatByIDReq, opts ...grpc.CallOption) (*StatByIDReply, error)
	// StatByIDGroupEvent spy stat by id or mid.
	StatByIDGroupEvent(ctx context.Context, in *StatByIDGroupEventReq, opts ...grpc.CallOption) (*StatByIDGroupEventReply, error)
	// PurgeUser purge  user info
	PurgeUser(ctx context.Context, in *PurgeUserReq, opts ...grpc.CallOption) (*PurgeUserReply, error)
	// HandleEvent handle spy-event.
	HandleEvent(ctx context.Context, in *HandleEventReq, opts ...grpc.CallOption) (*HandleEventReply, error)
	// UserInfo get UserInfo by mid , from cache or db or generate.
	UserInfo(ctx context.Context, in *UserInfoReq, opts ...grpc.CallOption) (*UserInfoReply, error)
	// UserInfoAsyn get UserInfo by mid , from cache or db or asyn generate.
	UserInfoAsyn(ctx context.Context, in *UserInfoAsynReq, opts ...grpc.CallOption) (*UserInfoAsynReply, error)
	// ReBuildPortrait reBuild user info.
	ReBuildPortrait(ctx context.Context, in *ReBuildPortraitReq, opts ...grpc.CallOption) (*ReBuildPortraitReply, error)
	// UpdateUserScore update user score
	UpdateUserScore(ctx context.Context, in *UpdateUserScoreReq, opts ...grpc.CallOption) (*UpdateUserScoreReply, error)
	// RefreshBaseScore refresh base score.
	RefreshBaseScore(ctx context.Context, in *RefreshBaseScoreReq, opts ...grpc.CallOption) (*RefreshBaseScoreReply, error)
	// UpdateBaseScore update base score.
	UpdateBaseScore(ctx context.Context, in *UpdateBaseScoreReq, opts ...grpc.CallOption) (*UpdateBaseScoreReply, error)
	// UpdateEventScore update event score.
	UpdateEventScore(ctx context.Context, in *UpdateEventScoreReq, opts ...grpc.CallOption) (*UpdateEventScoreReply, error)
	// ClearReliveTimes clear times.
	ClearReliveTimes(ctx context.Context, in *ClearReliveTimesReq, opts ...grpc.CallOption) (*ClearReliveTimesReply, error)
}

type spyClient struct {
	cc *grpc.ClientConn
}

func NewSpyClient(cc *grpc.ClientConn) SpyClient {
	return &spyClient{cc}
}

func (c *spyClient) Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingReply, error) {
	out := new(PingReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) Info(ctx context.Context, in *InfoReq, opts ...grpc.CallOption) (*InfoReply, error) {
	out := new(InfoReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/Info", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) StatByID(ctx context.Context, in *StatByIDReq, opts ...grpc.CallOption) (*StatByIDReply, error) {
	out := new(StatByIDReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/StatByID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) StatByIDGroupEvent(ctx context.Context, in *StatByIDGroupEventReq, opts ...grpc.CallOption) (*StatByIDGroupEventReply, error) {
	out := new(StatByIDGroupEventReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/StatByIDGroupEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) PurgeUser(ctx context.Context, in *PurgeUserReq, opts ...grpc.CallOption) (*PurgeUserReply, error) {
	out := new(PurgeUserReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/PurgeUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) HandleEvent(ctx context.Context, in *HandleEventReq, opts ...grpc.CallOption) (*HandleEventReply, error) {
	out := new(HandleEventReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/HandleEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) UserInfo(ctx context.Context, in *UserInfoReq, opts ...grpc.CallOption) (*UserInfoReply, error) {
	out := new(UserInfoReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/UserInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) UserInfoAsyn(ctx context.Context, in *UserInfoAsynReq, opts ...grpc.CallOption) (*UserInfoAsynReply, error) {
	out := new(UserInfoAsynReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/UserInfoAsyn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) ReBuildPortrait(ctx context.Context, in *ReBuildPortraitReq, opts ...grpc.CallOption) (*ReBuildPortraitReply, error) {
	out := new(ReBuildPortraitReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/ReBuildPortrait", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) UpdateUserScore(ctx context.Context, in *UpdateUserScoreReq, opts ...grpc.CallOption) (*UpdateUserScoreReply, error) {
	out := new(UpdateUserScoreReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/UpdateUserScore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) RefreshBaseScore(ctx context.Context, in *RefreshBaseScoreReq, opts ...grpc.CallOption) (*RefreshBaseScoreReply, error) {
	out := new(RefreshBaseScoreReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/RefreshBaseScore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) UpdateBaseScore(ctx context.Context, in *UpdateBaseScoreReq, opts ...grpc.CallOption) (*UpdateBaseScoreReply, error) {
	out := new(UpdateBaseScoreReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/UpdateBaseScore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) UpdateEventScore(ctx context.Context, in *UpdateEventScoreReq, opts ...grpc.CallOption) (*UpdateEventScoreReply, error) {
	out := new(UpdateEventScoreReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/UpdateEventScore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spyClient) ClearReliveTimes(ctx context.Context, in *ClearReliveTimesReq, opts ...grpc.CallOption) (*ClearReliveTimesReply, error) {
	out := new(ClearReliveTimesReply)
	err := c.cc.Invoke(ctx, "/account.spy.Spy/ClearReliveTimes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SpyServer is the server API for Spy service.
type SpyServer interface {
	// Ping check dao health.
	Ping(context.Context, *PingReq) (*PingReply, error)
	// Info get user info by mid.
	Info(context.Context, *InfoReq) (*InfoReply, error)
	// StatByID spy stat by id or mid.
	StatByID(context.Context, *StatByIDReq) (*StatByIDReply, error)
	// StatByIDGroupEvent spy stat by id or mid.
	StatByIDGroupEvent(context.Context, *StatByIDGroupEventReq) (*StatByIDGroupEventReply, error)
	// PurgeUser purge  user info
	PurgeUser(context.Context, *PurgeUserReq) (*PurgeUserReply, error)
	// HandleEvent handle spy-event.
	HandleEvent(context.Context, *HandleEventReq) (*HandleEventReply, error)
	// UserInfo get UserInfo by mid , from cache or db or generate.
	UserInfo(context.Context, *UserInfoReq) (*UserInfoReply, error)
	// UserInfoAsyn get UserInfo by mid , from cache or db or asyn generate.
	UserInfoAsyn(context.Context, *UserInfoAsynReq) (*UserInfoAsynReply, error)
	// ReBuildPortrait reBuild user info.
	ReBuildPortrait(context.Context, *ReBuildPortraitReq) (*ReBuildPortraitReply, error)
	// UpdateUserScore update user score
	UpdateUserScore(context.Context, *UpdateUserScoreReq) (*UpdateUserScoreReply, error)
	// RefreshBaseScore refresh base score.
	RefreshBaseScore(context.Context, *RefreshBaseScoreReq) (*RefreshBaseScoreReply, error)
	// UpdateBaseScore update base score.
	UpdateBaseScore(context.Context, *UpdateBaseScoreReq) (*UpdateBaseScoreReply, error)
	// UpdateEventScore update event score.
	UpdateEventScore(context.Context, *UpdateEventScoreReq) (*UpdateEventScoreReply, error)
	// ClearReliveTimes clear times.
	ClearReliveTimes(context.Context, *ClearReliveTimesReq) (*ClearReliveTimesReply, error)
}

func RegisterSpyServer(s *grpc.Server, srv SpyServer) {
	s.RegisterService(&_Spy_serviceDesc, srv)
}

func _Spy_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).Ping(ctx, req.(*PingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).Info(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/Info",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).Info(ctx, req.(*InfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_StatByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatByIDReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).StatByID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/StatByID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).StatByID(ctx, req.(*StatByIDReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_StatByIDGroupEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatByIDGroupEventReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).StatByIDGroupEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/StatByIDGroupEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).StatByIDGroupEvent(ctx, req.(*StatByIDGroupEventReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_PurgeUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PurgeUserReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).PurgeUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/PurgeUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).PurgeUser(ctx, req.(*PurgeUserReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_HandleEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HandleEventReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).HandleEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/HandleEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).HandleEvent(ctx, req.(*HandleEventReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_UserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).UserInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/UserInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).UserInfo(ctx, req.(*UserInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_UserInfoAsyn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserInfoAsynReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).UserInfoAsyn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/UserInfoAsyn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).UserInfoAsyn(ctx, req.(*UserInfoAsynReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_ReBuildPortrait_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReBuildPortraitReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).ReBuildPortrait(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/ReBuildPortrait",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).ReBuildPortrait(ctx, req.(*ReBuildPortraitReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_UpdateUserScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateUserScoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).UpdateUserScore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/UpdateUserScore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).UpdateUserScore(ctx, req.(*UpdateUserScoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_RefreshBaseScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RefreshBaseScoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).RefreshBaseScore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/RefreshBaseScore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).RefreshBaseScore(ctx, req.(*RefreshBaseScoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_UpdateBaseScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateBaseScoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).UpdateBaseScore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/UpdateBaseScore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).UpdateBaseScore(ctx, req.(*UpdateBaseScoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_UpdateEventScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateEventScoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).UpdateEventScore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/UpdateEventScore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).UpdateEventScore(ctx, req.(*UpdateEventScoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Spy_ClearReliveTimes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearReliveTimesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpyServer).ClearReliveTimes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/account.spy.Spy/ClearReliveTimes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpyServer).ClearReliveTimes(ctx, req.(*ClearReliveTimesReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Spy_serviceDesc = grpc.ServiceDesc{
	ServiceName: "account.spy.Spy",
	HandlerType: (*SpyServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _Spy_Ping_Handler,
		},
		{
			MethodName: "Info",
			Handler:    _Spy_Info_Handler,
		},
		{
			MethodName: "StatByID",
			Handler:    _Spy_StatByID_Handler,
		},
		{
			MethodName: "StatByIDGroupEvent",
			Handler:    _Spy_StatByIDGroupEvent_Handler,
		},
		{
			MethodName: "PurgeUser",
			Handler:    _Spy_PurgeUser_Handler,
		},
		{
			MethodName: "HandleEvent",
			Handler:    _Spy_HandleEvent_Handler,
		},
		{
			MethodName: "UserInfo",
			Handler:    _Spy_UserInfo_Handler,
		},
		{
			MethodName: "UserInfoAsyn",
			Handler:    _Spy_UserInfoAsyn_Handler,
		},
		{
			MethodName: "ReBuildPortrait",
			Handler:    _Spy_ReBuildPortrait_Handler,
		},
		{
			MethodName: "UpdateUserScore",
			Handler:    _Spy_UpdateUserScore_Handler,
		},
		{
			MethodName: "RefreshBaseScore",
			Handler:    _Spy_RefreshBaseScore_Handler,
		},
		{
			MethodName: "UpdateBaseScore",
			Handler:    _Spy_UpdateBaseScore_Handler,
		},
		{
			MethodName: "UpdateEventScore",
			Handler:    _Spy_UpdateEventScore_Handler,
		},
		{
			MethodName: "ClearReliveTimes",
			Handler:    _Spy_ClearReliveTimes_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/main/spy/api/api.proto",
}

func (m *ClearReliveTimesReply) 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 *ClearReliveTimesReply) 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 *ClearReliveTimesReq) 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 *ClearReliveTimesReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Arg.Size()))
		n1, err := m.Arg.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *HandleEventReply) 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 *HandleEventReply) 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 *HandleEventReq) 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 *HandleEventReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.EventMsg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.EventMsg.Size()))
		n2, err := m.EventMsg.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ModelArgReset) 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 *ModelArgReset) 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.ReLiveTime {
		dAtA[i] = 0x10
		i++
		if m.ReLiveTime {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.EventScore {
		dAtA[i] = 0x18
		i++
		if m.EventScore {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.BaseScore {
		dAtA[i] = 0x20
		i++
		if m.BaseScore {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Operator) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Operator)))
		i += copy(dAtA[i:], m.Operator)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ModelEventMessage) 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 *ModelEventMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Time != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Time))
	}
	if len(m.Ip) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Ip)))
		i += copy(dAtA[i:], m.Ip)
	}
	if len(m.Service) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Service)))
		i += copy(dAtA[i:], m.Service)
	}
	if len(m.Event) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Event)))
		i += copy(dAtA[i:], m.Event)
	}
	if m.ActiveMid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ActiveMid))
	}
	if m.TargetMid != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.TargetMid))
	}
	if m.TargetId != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.TargetId))
	}
	if len(m.Result) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Result)))
		i += copy(dAtA[i:], m.Result)
	}
	if len(m.Effect) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Effect)))
		i += copy(dAtA[i:], m.Effect)
	}
	if m.RiskLevel != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.RiskLevel))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ModelStatistics) 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 *ModelStatistics) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Quantity != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Quantity))
	}
	if m.EventId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.EventId))
	}
	if len(m.EventName) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.EventName)))
		i += copy(dAtA[i:], m.EventName)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ModelUserInfo) 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 *ModelUserInfo) 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.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Score != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Score))
	}
	if m.BaseScore != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.BaseScore))
	}
	if m.EventScore != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.EventScore))
	}
	if m.State != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.State))
	}
	if m.ReliveTimes != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ReliveTimes))
	}
	if m.Ctime != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ctime))
	}
	if m.Mtime != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mtime))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PingReply) 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 *PingReply) 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 *PingReq) 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 *PingReq) 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 *PurgeUserReply) 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 *PurgeUserReply) 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 *PurgeUserReq) 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 *PurgeUserReq) 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.Action) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Action)))
		i += copy(dAtA[i:], m.Action)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ReBuildPortraitReply) 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 *ReBuildPortraitReply) 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 *ReBuildPortraitReq) 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 *ReBuildPortraitReq) 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.Reason) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Reason)))
		i += copy(dAtA[i:], m.Reason)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *RefreshBaseScoreReply) 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 *RefreshBaseScoreReply) 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 *RefreshBaseScoreReq) 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 *RefreshBaseScoreReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Arg.Size()))
		n3, err := m.Arg.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StatByIDGroupEventReply) 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 *StatByIDGroupEventReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Res) > 0 {
		for _, msg := range m.Res {
			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 *StatByIDGroupEventReq) 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 *StatByIDGroupEventReq) 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.Id != 0 {
		dAtA[i] = 0x10
		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 *StatByIDReply) 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 *StatByIDReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Stat) > 0 {
		for _, msg := range m.Stat {
			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 *StatByIDReq) 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 *StatByIDReq) 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.Id != 0 {
		dAtA[i] = 0x10
		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 *UpdateBaseScoreReply) 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 *UpdateBaseScoreReply) 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 *UpdateBaseScoreReq) 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 *UpdateBaseScoreReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Arg.Size()))
		n4, err := m.Arg.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UpdateEventScoreReply) 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 *UpdateEventScoreReply) 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 *UpdateEventScoreReq) 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 *UpdateEventScoreReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Arg.Size()))
		n5, err := m.Arg.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UpdateUserScoreReply) 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 *UpdateUserScoreReply) 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 *UpdateUserScoreReq) 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 *UpdateUserScoreReq) 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.Ip) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Ip)))
		i += copy(dAtA[i:], m.Ip)
	}
	if len(m.Effect) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Effect)))
		i += copy(dAtA[i:], m.Effect)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UserInfoAsynReply) 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 *UserInfoAsynReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Ui != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ui.Size()))
		n6, err := m.Ui.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UserInfoAsynReq) 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 *UserInfoAsynReq) 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.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UserInfoReply) 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 *UserInfoReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Ui != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ui.Size()))
		n7, err := m.Ui.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UserInfoReq) 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 *UserInfoReq) 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.Ip) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Ip)))
		i += copy(dAtA[i:], m.Ip)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *InfoReq) 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 *InfoReq) 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.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *InfoReply) 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 *InfoReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Ui != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ui.Size()))
		n8, err := m.Ui.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	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 *ClearReliveTimesReply) 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 *ClearReliveTimesReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg != nil {
		l = m.Arg.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HandleEventReply) 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 *HandleEventReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EventMsg != nil {
		l = m.EventMsg.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModelArgReset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.ReLiveTime {
		n += 2
	}
	if m.EventScore {
		n += 2
	}
	if m.BaseScore {
		n += 2
	}
	l = len(m.Operator)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModelEventMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Time != 0 {
		n += 1 + sovApi(uint64(m.Time))
	}
	l = len(m.Ip)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Service)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Event)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.ActiveMid != 0 {
		n += 1 + sovApi(uint64(m.ActiveMid))
	}
	if m.TargetMid != 0 {
		n += 1 + sovApi(uint64(m.TargetMid))
	}
	if m.TargetId != 0 {
		n += 1 + sovApi(uint64(m.TargetId))
	}
	l = len(m.Result)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Effect)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.RiskLevel != 0 {
		n += 1 + sovApi(uint64(m.RiskLevel))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModelStatistics) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Quantity != 0 {
		n += 1 + sovApi(uint64(m.Quantity))
	}
	if m.EventId != 0 {
		n += 1 + sovApi(uint64(m.EventId))
	}
	l = len(m.EventName)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ModelUserInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovApi(uint64(m.Id))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Score != 0 {
		n += 1 + sovApi(uint64(m.Score))
	}
	if m.BaseScore != 0 {
		n += 1 + sovApi(uint64(m.BaseScore))
	}
	if m.EventScore != 0 {
		n += 1 + sovApi(uint64(m.EventScore))
	}
	if m.State != 0 {
		n += 1 + sovApi(uint64(m.State))
	}
	if m.ReliveTimes != 0 {
		n += 1 + sovApi(uint64(m.ReliveTimes))
	}
	if m.Ctime != 0 {
		n += 1 + sovApi(uint64(m.Ctime))
	}
	if m.Mtime != 0 {
		n += 1 + sovApi(uint64(m.Mtime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PingReply) 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 *PingReq) 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 *PurgeUserReply) 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 *PurgeUserReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Action)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ReBuildPortraitReply) 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 *ReBuildPortraitReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RefreshBaseScoreReply) 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 *RefreshBaseScoreReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg != nil {
		l = m.Arg.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func (m *UpdateBaseScoreReply) 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 *UpdateBaseScoreReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg != nil {
		l = m.Arg.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateEventScoreReply) 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 *UpdateEventScoreReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg != nil {
		l = m.Arg.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UpdateUserScoreReply) 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 *UpdateUserScoreReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Ip)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Effect)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

func (m *InfoReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ui != nil {
		l = m.Ui.Size()
		n += 1 + l + sovApi(uint64(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 *ClearReliveTimesReply) 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: ClearReliveTimesReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClearReliveTimesReply: 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 *ClearReliveTimesReq) 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: ClearReliveTimesReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClearReliveTimesReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arg", 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.Arg == nil {
				m.Arg = &ModelArgReset{}
			}
			if err := m.Arg.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 *HandleEventReply) 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: HandleEventReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HandleEventReply: 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 *HandleEventReq) 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: HandleEventReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HandleEventReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventMsg", 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.EventMsg == nil {
				m.EventMsg = &ModelEventMessage{}
			}
			if err := m.EventMsg.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 *ModelArgReset) 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: ModelArgReset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModelArgReset: 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 ReLiveTime", 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.ReLiveTime = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventScore", 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.EventScore = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseScore", 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.BaseScore = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operator", 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.Operator = 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 *ModelEventMessage) 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: ModelEventMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModelEventMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ip", 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.Ip = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", 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.Service = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", 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.Event = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveMid", wireType)
			}
			m.ActiveMid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActiveMid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetMid", wireType)
			}
			m.TargetMid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetMid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
			}
			m.TargetId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TargetId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", 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.Result = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Effect", 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.Effect = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RiskLevel", wireType)
			}
			m.RiskLevel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RiskLevel |= (int32(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 *ModelStatistics) 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: ModelStatistics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModelStatistics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quantity", wireType)
			}
			m.Quantity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Quantity |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventId", wireType)
			}
			m.EventId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventName", 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.EventName = 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 *ModelUserInfo) 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: ModelUserInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModelUserInfo: 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 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 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			m.Score = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Score |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseScore", wireType)
			}
			m.BaseScore = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BaseScore |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventScore", wireType)
			}
			m.EventScore = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventScore |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReliveTimes", wireType)
			}
			m.ReliveTimes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReliveTimes |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ctime", wireType)
			}
			m.Ctime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ctime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mtime", wireType)
			}
			m.Mtime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mtime |= (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 *PingReply) 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: PingReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingReply: 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 *PingReq) 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: PingReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingReq: 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 *PurgeUserReply) 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: PurgeUserReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PurgeUserReply: 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 *PurgeUserReq) 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: PurgeUserReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PurgeUserReq: 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 Action", 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.Action = 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 *ReBuildPortraitReply) 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: ReBuildPortraitReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReBuildPortraitReply: 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 *ReBuildPortraitReq) 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: ReBuildPortraitReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReBuildPortraitReq: 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 Reason", 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.Reason = 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 *RefreshBaseScoreReply) 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: RefreshBaseScoreReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RefreshBaseScoreReply: 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 *RefreshBaseScoreReq) 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: RefreshBaseScoreReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RefreshBaseScoreReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arg", 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.Arg == nil {
				m.Arg = &ModelArgReset{}
			}
			if err := m.Arg.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 *StatByIDGroupEventReply) 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: StatByIDGroupEventReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatByIDGroupEventReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Res", 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.Res = append(m.Res, &ModelStatistics{})
			if err := m.Res[len(m.Res)-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 *StatByIDGroupEventReq) 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: StatByIDGroupEventReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatByIDGroupEventReq: 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 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 *StatByIDReply) 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: StatByIDReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatByIDReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stat", 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.Stat = append(m.Stat, &ModelStatistics{})
			if err := m.Stat[len(m.Stat)-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 *StatByIDReq) 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: StatByIDReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatByIDReq: 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 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 *UpdateBaseScoreReply) 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: UpdateBaseScoreReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateBaseScoreReply: 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 *UpdateBaseScoreReq) 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: UpdateBaseScoreReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateBaseScoreReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arg", 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.Arg == nil {
				m.Arg = &ModelArgReset{}
			}
			if err := m.Arg.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 *UpdateEventScoreReply) 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: UpdateEventScoreReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateEventScoreReply: 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 *UpdateEventScoreReq) 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: UpdateEventScoreReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateEventScoreReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arg", 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.Arg == nil {
				m.Arg = &ModelArgReset{}
			}
			if err := m.Arg.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 *UpdateUserScoreReply) 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: UpdateUserScoreReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateUserScoreReply: 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 *UpdateUserScoreReq) 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: UpdateUserScoreReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateUserScoreReq: 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 Ip", 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.Ip = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Effect", 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.Effect = 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 *UserInfoAsynReply) 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: UserInfoAsynReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserInfoAsynReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ui", 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.Ui == nil {
				m.Ui = &ModelUserInfo{}
			}
			if err := m.Ui.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 *UserInfoAsynReq) 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: UserInfoAsynReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserInfoAsynReq: 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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InfoReply) 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: InfoReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InfoReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ui", 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.Ui == nil {
				m.Ui = &ModelUserInfo{}
			}
			if err := m.Ui.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 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/spy/api/api.proto", fileDescriptor_api_6dc8e2021997d22c)
}

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