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

/*
	Package v1 is a generated protocol buffer package.

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

	It has these top-level messages:
		ModelReport
		AddReportRequest
		AddReportReply
		DelReportRequest
		DelReportReply
		DelInvalidReportsRequest
		DelInvalidReportsReply
		AddReportCacheRequest
		AddReportCacheReply
		AddUserReportCacheRequest
		AddUserReportCacheReply
		AddTokenCacheRequest
		AddTokenCacheReply
		AddTokensCacheRequest
		AddTokensCacheReply
		AddCallbackRequest
		AddCallbackReply
		CallbackExtra
		AddMidProgressRequest
		AddMidProgressReply
		SettingRequest
		SettingReply
		SetSettingRequest
		SetSettingReply
*/
package v1

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

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

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type ModelReport struct {
	ID           int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	APPID        int32  `protobuf:"varint,2,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	PlatformID   int32  `protobuf:"varint,3,opt,name=platform_id,json=platformId,proto3" json:"platform_id,omitempty"`
	Mid          int64  `protobuf:"varint,4,opt,name=mid,proto3" json:"mid,omitempty"`
	Buvid        string `protobuf:"bytes,5,opt,name=buvid,proto3" json:"buvid,omitempty"`
	DeviceToken  string `protobuf:"bytes,6,opt,name=device_token,json=deviceToken,proto3" json:"device_token,omitempty"`
	Build        int32  `protobuf:"varint,7,opt,name=build,proto3" json:"build,omitempty"`
	TimeZone     int32  `protobuf:"varint,8,opt,name=time_zone,json=timeZone,proto3" json:"time_zone,omitempty"`
	NotifySwitch int32  `protobuf:"varint,9,opt,name=notify_switch,json=notifySwitch,proto3" json:"notify_switch,omitempty"`
	DeviceBrand  string `protobuf:"bytes,10,opt,name=device_brand,json=deviceBrand,proto3" json:"device_brand,omitempty"`
	DeviceModel  string `protobuf:"bytes,11,opt,name=device_model,json=deviceModel,proto3" json:"device_model,omitempty"`
	OSVersion    string `protobuf:"bytes,12,opt,name=os_version,json=osVersion,proto3" json:"os_version,omitempty"`
	Extra        string `protobuf:"bytes,13,opt,name=extra,proto3" json:"extra,omitempty"`
}

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

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

func (m *ModelReport) GetAPPID() int32 {
	if m != nil {
		return m.APPID
	}
	return 0
}

func (m *ModelReport) GetPlatformID() int32 {
	if m != nil {
		return m.PlatformID
	}
	return 0
}

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

func (m *ModelReport) GetBuvid() string {
	if m != nil {
		return m.Buvid
	}
	return ""
}

func (m *ModelReport) GetDeviceToken() string {
	if m != nil {
		return m.DeviceToken
	}
	return ""
}

func (m *ModelReport) GetBuild() int32 {
	if m != nil {
		return m.Build
	}
	return 0
}

func (m *ModelReport) GetTimeZone() int32 {
	if m != nil {
		return m.TimeZone
	}
	return 0
}

func (m *ModelReport) GetNotifySwitch() int32 {
	if m != nil {
		return m.NotifySwitch
	}
	return 0
}

func (m *ModelReport) GetDeviceBrand() string {
	if m != nil {
		return m.DeviceBrand
	}
	return ""
}

func (m *ModelReport) GetDeviceModel() string {
	if m != nil {
		return m.DeviceModel
	}
	return ""
}

func (m *ModelReport) GetOSVersion() string {
	if m != nil {
		return m.OSVersion
	}
	return ""
}

func (m *ModelReport) GetExtra() string {
	if m != nil {
		return m.Extra
	}
	return ""
}

type AddReportRequest struct {
	Report *ModelReport `protobuf:"bytes,1,opt,name=report" json:"report,omitempty"`
}

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

func (m *AddReportRequest) GetReport() *ModelReport {
	if m != nil {
		return m.Report
	}
	return nil
}

type AddReportReply struct {
}

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

type DelReportRequest struct {
	APPID       int32  `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	Mid         int64  `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	DeviceToken string `protobuf:"bytes,3,opt,name=device_token,json=deviceToken,proto3" json:"device_token,omitempty"`
}

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

func (m *DelReportRequest) GetAPPID() int32 {
	if m != nil {
		return m.APPID
	}
	return 0
}

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

func (m *DelReportRequest) GetDeviceToken() string {
	if m != nil {
		return m.DeviceToken
	}
	return ""
}

type DelReportReply struct {
}

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

type DelInvalidReportsRequest struct {
	Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
}

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

func (m *DelInvalidReportsRequest) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

type DelInvalidReportsReply struct {
}

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

type AddReportCacheRequest struct {
	Report *ModelReport `protobuf:"bytes,1,opt,name=report" json:"report,omitempty"`
}

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

func (m *AddReportCacheRequest) GetReport() *ModelReport {
	if m != nil {
		return m.Report
	}
	return nil
}

type AddReportCacheReply struct {
}

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

type AddUserReportCacheRequest struct {
	Mid     int64          `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Reports []*ModelReport `protobuf:"bytes,2,rep,name=reports" json:"reports,omitempty"`
}

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

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

func (m *AddUserReportCacheRequest) GetReports() []*ModelReport {
	if m != nil {
		return m.Reports
	}
	return nil
}

type AddUserReportCacheReply struct {
}

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

type AddTokenCacheRequest struct {
	Report *ModelReport `protobuf:"bytes,1,opt,name=report" json:"report,omitempty"`
}

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

func (m *AddTokenCacheRequest) GetReport() *ModelReport {
	if m != nil {
		return m.Report
	}
	return nil
}

type AddTokenCacheReply struct {
}

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

type AddTokensCacheRequest struct {
	Reports []*ModelReport `protobuf:"bytes,2,rep,name=reports" json:"reports,omitempty"`
}

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

func (m *AddTokensCacheRequest) GetReports() []*ModelReport {
	if m != nil {
		return m.Reports
	}
	return nil
}

type AddTokensCacheReply struct {
}

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

type AddCallbackRequest struct {
	Task     string         `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	APP      int64          `protobuf:"varint,2,opt,name=app,proto3" json:"app,omitempty"`
	Platform int32          `protobuf:"varint,3,opt,name=platform,proto3" json:"platform,omitempty"`
	Mid      int64          `protobuf:"varint,4,opt,name=mid,proto3" json:"mid,omitempty"`
	Pid      int32          `protobuf:"varint,5,opt,name=pid,proto3" json:"pid,omitempty"`
	Token    string         `protobuf:"bytes,6,opt,name=token,proto3" json:"token,omitempty"`
	Buvid    string         `protobuf:"bytes,7,opt,name=buvid,proto3" json:"buvid,omitempty"`
	Click    int32          `protobuf:"varint,8,opt,name=click,proto3" json:"click,omitempty"`
	Extra    *CallbackExtra `protobuf:"bytes,9,opt,name=extra" json:"extra,omitempty"`
}

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

func (m *AddCallbackRequest) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

func (m *AddCallbackRequest) GetAPP() int64 {
	if m != nil {
		return m.APP
	}
	return 0
}

func (m *AddCallbackRequest) GetPlatform() int32 {
	if m != nil {
		return m.Platform
	}
	return 0
}

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

func (m *AddCallbackRequest) GetPid() int32 {
	if m != nil {
		return m.Pid
	}
	return 0
}

func (m *AddCallbackRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *AddCallbackRequest) GetBuvid() string {
	if m != nil {
		return m.Buvid
	}
	return ""
}

func (m *AddCallbackRequest) GetClick() int32 {
	if m != nil {
		return m.Click
	}
	return 0
}

func (m *AddCallbackRequest) GetExtra() *CallbackExtra {
	if m != nil {
		return m.Extra
	}
	return nil
}

type AddCallbackReply struct {
}

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

type CallbackExtra struct {
	Status  int32 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty" json:"st`
	Channel int32 `protobuf:"varint,2,opt,name=channel,proto3" json:"channel,omitempty" json:"chan"`
}

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

func (m *CallbackExtra) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

func (m *CallbackExtra) GetChannel() int32 {
	if m != nil {
		return m.Channel
	}
	return 0
}

type AddMidProgressRequest struct {
	Task     string `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
	MidTotal int64  `protobuf:"varint,2,opt,name=mid_total,json=midTotal,proto3" json:"mid_total,omitempty"`
	MidValid int64  `protobuf:"varint,3,opt,name=mid_valid,json=midValid,proto3" json:"mid_valid,omitempty"`
}

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

func (m *AddMidProgressRequest) GetTask() string {
	if m != nil {
		return m.Task
	}
	return ""
}

func (m *AddMidProgressRequest) GetMidTotal() int64 {
	if m != nil {
		return m.MidTotal
	}
	return 0
}

func (m *AddMidProgressRequest) GetMidValid() int64 {
	if m != nil {
		return m.MidValid
	}
	return 0
}

type AddMidProgressReply struct {
}

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

type SettingRequest struct {
	Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
}

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

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

type SettingReply struct {
	Settings map[int32]int32 `protobuf:"bytes,1,rep,name=settings" json:"settings,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
}

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

func (m *SettingReply) GetSettings() map[int32]int32 {
	if m != nil {
		return m.Settings
	}
	return nil
}

type SetSettingRequest struct {
	Mid   int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Type  int32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	Value int32 `protobuf:"varint,3,opt,name=value,proto3" json:"value,omitempty"`
}

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

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

func (m *SetSettingRequest) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *SetSettingRequest) GetValue() int32 {
	if m != nil {
		return m.Value
	}
	return 0
}

type SetSettingReply struct {
}

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

func init() {
	proto.RegisterType((*ModelReport)(nil), "push.service.v1.ModelReport")
	proto.RegisterType((*AddReportRequest)(nil), "push.service.v1.AddReportRequest")
	proto.RegisterType((*AddReportReply)(nil), "push.service.v1.AddReportReply")
	proto.RegisterType((*DelReportRequest)(nil), "push.service.v1.DelReportRequest")
	proto.RegisterType((*DelReportReply)(nil), "push.service.v1.DelReportReply")
	proto.RegisterType((*DelInvalidReportsRequest)(nil), "push.service.v1.DelInvalidReportsRequest")
	proto.RegisterType((*DelInvalidReportsReply)(nil), "push.service.v1.DelInvalidReportsReply")
	proto.RegisterType((*AddReportCacheRequest)(nil), "push.service.v1.AddReportCacheRequest")
	proto.RegisterType((*AddReportCacheReply)(nil), "push.service.v1.AddReportCacheReply")
	proto.RegisterType((*AddUserReportCacheRequest)(nil), "push.service.v1.AddUserReportCacheRequest")
	proto.RegisterType((*AddUserReportCacheReply)(nil), "push.service.v1.AddUserReportCacheReply")
	proto.RegisterType((*AddTokenCacheRequest)(nil), "push.service.v1.AddTokenCacheRequest")
	proto.RegisterType((*AddTokenCacheReply)(nil), "push.service.v1.AddTokenCacheReply")
	proto.RegisterType((*AddTokensCacheRequest)(nil), "push.service.v1.AddTokensCacheRequest")
	proto.RegisterType((*AddTokensCacheReply)(nil), "push.service.v1.AddTokensCacheReply")
	proto.RegisterType((*AddCallbackRequest)(nil), "push.service.v1.AddCallbackRequest")
	proto.RegisterType((*AddCallbackReply)(nil), "push.service.v1.AddCallbackReply")
	proto.RegisterType((*CallbackExtra)(nil), "push.service.v1.CallbackExtra")
	proto.RegisterType((*AddMidProgressRequest)(nil), "push.service.v1.AddMidProgressRequest")
	proto.RegisterType((*AddMidProgressReply)(nil), "push.service.v1.AddMidProgressReply")
	proto.RegisterType((*SettingRequest)(nil), "push.service.v1.SettingRequest")
	proto.RegisterType((*SettingReply)(nil), "push.service.v1.SettingReply")
	proto.RegisterType((*SetSettingRequest)(nil), "push.service.v1.SetSettingRequest")
	proto.RegisterType((*SetSettingReply)(nil), "push.service.v1.SetSettingReply")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Push service

type PushClient interface {
	AddReport(ctx context.Context, in *AddReportRequest, opts ...grpc.CallOption) (*AddReportReply, error)
	DelReport(ctx context.Context, in *DelReportRequest, opts ...grpc.CallOption) (*DelReportReply, error)
	DelInvalidReports(ctx context.Context, in *DelInvalidReportsRequest, opts ...grpc.CallOption) (*DelInvalidReportsReply, error)
	AddReportCache(ctx context.Context, in *AddReportCacheRequest, opts ...grpc.CallOption) (*AddReportCacheReply, error)
	AddUserReportCache(ctx context.Context, in *AddUserReportCacheRequest, opts ...grpc.CallOption) (*AddUserReportCacheReply, error)
	AddTokenCache(ctx context.Context, in *AddTokenCacheRequest, opts ...grpc.CallOption) (*AddTokenCacheReply, error)
	AddTokensCache(ctx context.Context, in *AddTokensCacheRequest, opts ...grpc.CallOption) (*AddTokensCacheReply, error)
	AddCallback(ctx context.Context, in *AddCallbackRequest, opts ...grpc.CallOption) (*AddCallbackReply, error)
	AddMidProgress(ctx context.Context, in *AddMidProgressRequest, opts ...grpc.CallOption) (*AddMidProgressReply, error)
	Setting(ctx context.Context, in *SettingRequest, opts ...grpc.CallOption) (*SettingReply, error)
	SetSetting(ctx context.Context, in *SetSettingRequest, opts ...grpc.CallOption) (*SetSettingReply, error)
}

type pushClient struct {
	cc *grpc.ClientConn
}

func NewPushClient(cc *grpc.ClientConn) PushClient {
	return &pushClient{cc}
}

func (c *pushClient) AddReport(ctx context.Context, in *AddReportRequest, opts ...grpc.CallOption) (*AddReportReply, error) {
	out := new(AddReportReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddReport", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) DelReport(ctx context.Context, in *DelReportRequest, opts ...grpc.CallOption) (*DelReportReply, error) {
	out := new(DelReportReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/DelReport", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) DelInvalidReports(ctx context.Context, in *DelInvalidReportsRequest, opts ...grpc.CallOption) (*DelInvalidReportsReply, error) {
	out := new(DelInvalidReportsReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/DelInvalidReports", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) AddReportCache(ctx context.Context, in *AddReportCacheRequest, opts ...grpc.CallOption) (*AddReportCacheReply, error) {
	out := new(AddReportCacheReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddReportCache", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) AddUserReportCache(ctx context.Context, in *AddUserReportCacheRequest, opts ...grpc.CallOption) (*AddUserReportCacheReply, error) {
	out := new(AddUserReportCacheReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddUserReportCache", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) AddTokenCache(ctx context.Context, in *AddTokenCacheRequest, opts ...grpc.CallOption) (*AddTokenCacheReply, error) {
	out := new(AddTokenCacheReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddTokenCache", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) AddTokensCache(ctx context.Context, in *AddTokensCacheRequest, opts ...grpc.CallOption) (*AddTokensCacheReply, error) {
	out := new(AddTokensCacheReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddTokensCache", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) AddCallback(ctx context.Context, in *AddCallbackRequest, opts ...grpc.CallOption) (*AddCallbackReply, error) {
	out := new(AddCallbackReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddCallback", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) AddMidProgress(ctx context.Context, in *AddMidProgressRequest, opts ...grpc.CallOption) (*AddMidProgressReply, error) {
	out := new(AddMidProgressReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/AddMidProgress", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) Setting(ctx context.Context, in *SettingRequest, opts ...grpc.CallOption) (*SettingReply, error) {
	out := new(SettingReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/Setting", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushClient) SetSetting(ctx context.Context, in *SetSettingRequest, opts ...grpc.CallOption) (*SetSettingReply, error) {
	out := new(SetSettingReply)
	err := grpc.Invoke(ctx, "/push.service.v1.Push/SetSetting", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Push service

type PushServer interface {
	AddReport(context.Context, *AddReportRequest) (*AddReportReply, error)
	DelReport(context.Context, *DelReportRequest) (*DelReportReply, error)
	DelInvalidReports(context.Context, *DelInvalidReportsRequest) (*DelInvalidReportsReply, error)
	AddReportCache(context.Context, *AddReportCacheRequest) (*AddReportCacheReply, error)
	AddUserReportCache(context.Context, *AddUserReportCacheRequest) (*AddUserReportCacheReply, error)
	AddTokenCache(context.Context, *AddTokenCacheRequest) (*AddTokenCacheReply, error)
	AddTokensCache(context.Context, *AddTokensCacheRequest) (*AddTokensCacheReply, error)
	AddCallback(context.Context, *AddCallbackRequest) (*AddCallbackReply, error)
	AddMidProgress(context.Context, *AddMidProgressRequest) (*AddMidProgressReply, error)
	Setting(context.Context, *SettingRequest) (*SettingReply, error)
	SetSetting(context.Context, *SetSettingRequest) (*SetSettingReply, error)
}

func RegisterPushServer(s *grpc.Server, srv PushServer) {
	s.RegisterService(&_Push_serviceDesc, srv)
}

func _Push_AddReport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddReportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddReport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddReport",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddReport(ctx, req.(*AddReportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_DelReport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelReportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).DelReport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/DelReport",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).DelReport(ctx, req.(*DelReportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_DelInvalidReports_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelInvalidReportsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).DelInvalidReports(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/DelInvalidReports",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).DelInvalidReports(ctx, req.(*DelInvalidReportsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_AddReportCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddReportCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddReportCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddReportCache",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddReportCache(ctx, req.(*AddReportCacheRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_AddUserReportCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddUserReportCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddUserReportCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddUserReportCache",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddUserReportCache(ctx, req.(*AddUserReportCacheRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_AddTokenCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTokenCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddTokenCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddTokenCache",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddTokenCache(ctx, req.(*AddTokenCacheRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_AddTokensCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTokensCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddTokensCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddTokensCache",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddTokensCache(ctx, req.(*AddTokensCacheRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_AddCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddCallbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddCallback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddCallback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddCallback(ctx, req.(*AddCallbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_AddMidProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddMidProgressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).AddMidProgress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/AddMidProgress",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).AddMidProgress(ctx, req.(*AddMidProgressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_Setting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SettingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).Setting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/Setting",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).Setting(ctx, req.(*SettingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Push_SetSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSettingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServer).SetSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.v1.Push/SetSetting",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServer).SetSetting(ctx, req.(*SetSettingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Push_serviceDesc = grpc.ServiceDesc{
	ServiceName: "push.service.v1.Push",
	HandlerType: (*PushServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddReport",
			Handler:    _Push_AddReport_Handler,
		},
		{
			MethodName: "DelReport",
			Handler:    _Push_DelReport_Handler,
		},
		{
			MethodName: "DelInvalidReports",
			Handler:    _Push_DelInvalidReports_Handler,
		},
		{
			MethodName: "AddReportCache",
			Handler:    _Push_AddReportCache_Handler,
		},
		{
			MethodName: "AddUserReportCache",
			Handler:    _Push_AddUserReportCache_Handler,
		},
		{
			MethodName: "AddTokenCache",
			Handler:    _Push_AddTokenCache_Handler,
		},
		{
			MethodName: "AddTokensCache",
			Handler:    _Push_AddTokensCache_Handler,
		},
		{
			MethodName: "AddCallback",
			Handler:    _Push_AddCallback_Handler,
		},
		{
			MethodName: "AddMidProgress",
			Handler:    _Push_AddMidProgress_Handler,
		},
		{
			MethodName: "Setting",
			Handler:    _Push_Setting_Handler,
		},
		{
			MethodName: "SetSetting",
			Handler:    _Push_SetSetting_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/main/push/api/grpc/v1/api.proto",
}

func (m *ModelReport) 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 *ModelReport) 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.APPID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.APPID))
	}
	if m.PlatformID != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.PlatformID))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Buvid) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Buvid)))
		i += copy(dAtA[i:], m.Buvid)
	}
	if len(m.DeviceToken) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.DeviceToken)))
		i += copy(dAtA[i:], m.DeviceToken)
	}
	if m.Build != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Build))
	}
	if m.TimeZone != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.TimeZone))
	}
	if m.NotifySwitch != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.NotifySwitch))
	}
	if len(m.DeviceBrand) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.DeviceBrand)))
		i += copy(dAtA[i:], m.DeviceBrand)
	}
	if len(m.DeviceModel) > 0 {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.DeviceModel)))
		i += copy(dAtA[i:], m.DeviceModel)
	}
	if len(m.OSVersion) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.OSVersion)))
		i += copy(dAtA[i:], m.OSVersion)
	}
	if len(m.Extra) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Extra)))
		i += copy(dAtA[i:], m.Extra)
	}
	return i, nil
}

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

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

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

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

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

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

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

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

func (m *AddUserReportCacheRequest) 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 *AddUserReportCacheRequest) 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.Reports) > 0 {
		for _, msg := range m.Reports {
			dAtA[i] = 0x12
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

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

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

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

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

func (m *AddCallbackRequest) 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 *AddCallbackRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Task) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Task)))
		i += copy(dAtA[i:], m.Task)
	}
	if m.APP != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.APP))
	}
	if m.Platform != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Platform))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Pid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Pid))
	}
	if len(m.Token) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Token)))
		i += copy(dAtA[i:], m.Token)
	}
	if len(m.Buvid) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Buvid)))
		i += copy(dAtA[i:], m.Buvid)
	}
	if m.Click != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Click))
	}
	if m.Extra != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Extra.Size()))
		n4, err := m.Extra.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

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

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

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

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

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

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

func (m *SetSettingRequest) 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 *SetSettingRequest) 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.Type != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Type))
	}
	if m.Value != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Value))
	}
	return i, nil
}

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

func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *ModelReport) Size() (n int) {
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovApi(uint64(m.ID))
	}
	if m.APPID != 0 {
		n += 1 + sovApi(uint64(m.APPID))
	}
	if m.PlatformID != 0 {
		n += 1 + sovApi(uint64(m.PlatformID))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Buvid)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.DeviceToken)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Build != 0 {
		n += 1 + sovApi(uint64(m.Build))
	}
	if m.TimeZone != 0 {
		n += 1 + sovApi(uint64(m.TimeZone))
	}
	if m.NotifySwitch != 0 {
		n += 1 + sovApi(uint64(m.NotifySwitch))
	}
	l = len(m.DeviceBrand)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.DeviceModel)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.OSVersion)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Extra)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *AddReportRequest) Size() (n int) {
	var l int
	_ = l
	if m.Report != nil {
		l = m.Report.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

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

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

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

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

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

func (m *AddReportCacheRequest) Size() (n int) {
	var l int
	_ = l
	if m.Report != nil {
		l = m.Report.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

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

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

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

func (m *AddTokenCacheRequest) Size() (n int) {
	var l int
	_ = l
	if m.Report != nil {
		l = m.Report.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

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

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

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

func (m *AddCallbackRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.APP != 0 {
		n += 1 + sovApi(uint64(m.APP))
	}
	if m.Platform != 0 {
		n += 1 + sovApi(uint64(m.Platform))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Pid != 0 {
		n += 1 + sovApi(uint64(m.Pid))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Buvid)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Click != 0 {
		n += 1 + sovApi(uint64(m.Click))
	}
	if m.Extra != nil {
		l = m.Extra.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

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

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

func (m *AddMidProgressRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.Task)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.MidTotal != 0 {
		n += 1 + sovApi(uint64(m.MidTotal))
	}
	if m.MidValid != 0 {
		n += 1 + sovApi(uint64(m.MidValid))
	}
	return n
}

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

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

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

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

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

func sovApi(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ModelReport) 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: ModelReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModelReport: 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 APPID", wireType)
			}
			m.APPID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.APPID |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlatformID", wireType)
			}
			m.PlatformID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlatformID |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buvid", 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.Buvid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceToken", 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.DeviceToken = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Build", wireType)
			}
			m.Build = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Build |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeZone", wireType)
			}
			m.TimeZone = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeZone |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotifySwitch", wireType)
			}
			m.NotifySwitch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NotifySwitch |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceBrand", 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.DeviceBrand = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceModel", 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.DeviceModel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OSVersion", 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.OSVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", 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.Extra = 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
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddReportRequest) 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: AddReportRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddReportRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Report", 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.Report == nil {
				m.Report = &ModelReport{}
			}
			if err := m.Report.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddReportCacheRequest) 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: AddReportCacheRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddReportCacheRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Report", 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.Report == nil {
				m.Report = &ModelReport{}
			}
			if err := m.Report.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddUserReportCacheRequest) 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: AddUserReportCacheRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddUserReportCacheRequest: 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 Reports", 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.Reports = append(m.Reports, &ModelReport{})
			if err := m.Reports[len(m.Reports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddTokenCacheRequest) 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: AddTokenCacheRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddTokenCacheRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Report", 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.Report == nil {
				m.Report = &ModelReport{}
			}
			if err := m.Report.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddTokensCacheRequest) 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: AddTokensCacheRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddTokensCacheRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reports", 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.Reports = append(m.Reports, &ModelReport{})
			if err := m.Reports[len(m.Reports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddCallbackRequest) 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: AddCallbackRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddCallbackRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", 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.Task = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field APP", wireType)
			}
			m.APP = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.APP |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
			}
			m.Platform = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Platform |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)
			}
			m.Pid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pid |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", 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.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Buvid", 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.Buvid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Click", wireType)
			}
			m.Click = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Click |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extra", 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.Extra == nil {
				m.Extra = &CallbackExtra{}
			}
			if err := m.Extra.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetSettingRequest) 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: SetSettingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetSettingRequest: 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 Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= (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
			}
			iNdEx += skippy
		}
	}

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

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

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

func init() { proto.RegisterFile("app/service/main/push/api/grpc/v1/api.proto", fileDescriptorApi) }

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