// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/bbq/notice-service/api/v1/api.proto

package v1

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

import go_common_library_time "go-common/library/time"

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

import io "io"

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

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

type GetUnreadInfoRequest struct {
	// 用户mid
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid" form:"mid" validate:"required"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetUnreadInfoRequest proto.InternalMessageInfo

type UnreadInfo struct {
	// 用户mid
	List                 []*UnreadItem `protobuf:"bytes,1,rep,name=list" json:"list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_UnreadInfo proto.InternalMessageInfo

type UnreadItem struct {
	NoticeType           int32    `protobuf:"varint,1,opt,name=notice_type,json=noticeType,proto3" json:"notice_type"`
	UnreadNum            int64    `protobuf:"varint,2,opt,name=unread_num,json=unreadNum,proto3" json:"unread_num"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UnreadItem proto.InternalMessageInfo

type ListNoticesReq struct {
	// 用户mid
	Mid                  int64    `protobuf:"varint,1,opt,name=mid,proto3" json:"mid" form:"mid" validate:"required"`
	NoticeType           int32    `protobuf:"varint,2,opt,name=notice_type,json=noticeType,proto3" json:"notice_type" form:"notice_type" validate:"required"`
	CursorId             int64    `protobuf:"varint,3,opt,name=cursor_id,json=cursorId,proto3" json:"cursor_id" form:"cursor_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListNoticesReq proto.InternalMessageInfo

type ListNoticesReply struct {
	// 用户mid
	Mid                  int64         `protobuf:"varint,1,opt,name=mid,proto3" json:"mid"`
	List                 []*NoticeBase `protobuf:"bytes,2,rep,name=list" json:"list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_ListNoticesReply proto.InternalMessageInfo

type NoticeBase struct {
	Id                   int64                       `protobuf:"varint,1,opt,name=id,proto3" json:"id"`
	Mid                  int64                       `protobuf:"varint,2,opt,name=mid,proto3" json:"mid" form:"mid" validate:"required"`
	ActionMid            int64                       `protobuf:"varint,3,opt,name=action_mid,json=actionMid,proto3" json:"action_mid" form:"action_mid"`
	SvId                 int64                       `protobuf:"varint,4,opt,name=sv_id,json=svId,proto3" json:"svid" form:"svid"`
	Title                string                      `protobuf:"bytes,5,opt,name=title,proto3" json:"title" form:"title"`
	Text                 string                      `protobuf:"bytes,6,opt,name=text,proto3" json:"text" form:"text"`
	JumpUrl              string                      `protobuf:"bytes,7,opt,name=jump_url,json=jumpUrl,proto3" json:"jump_url" form:"jump_url"`
	NoticeType           int32                       `protobuf:"varint,8,opt,name=notice_type,json=noticeType,proto3" json:"notice_type" form:"notice_type" validate:"required"`
	BizType              int32                       `protobuf:"varint,9,opt,name=biz_type,json=bizType,proto3" json:"biz_type" form:"biz_type"`
	BizId                int64                       `protobuf:"varint,10,opt,name=biz_id,json=bizId,proto3" json:"biz_id" form:"biz_id"`
	NoticeTime           go_common_library_time.Time `protobuf:"varint,11,opt,name=notice_time,json=noticeTime,proto3,casttype=go-common/library/time.Time" json:"notice_time"`
	Buvid                string                      `protobuf:"bytes,12,opt,name=buvid,proto3" json:"buvid" form:"buvid"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_NoticeBase proto.InternalMessageInfo

type CreateNoticesReq struct {
	Notices              []*NoticeBase `protobuf:"bytes,1,rep,name=notices" json:"notices" form:"notices" validate:"required"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_CreateNoticesReq proto.InternalMessageInfo

type CreateNoticesReply struct {
	// 失败的列表
	FailList             []int64  `protobuf:"varint,2,rep,packed,name=fail_list,json=failList" json:"fail_list"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreateNoticesReply proto.InternalMessageInfo

type PushCallbackRequest struct {
	Tid                  string   `protobuf:"bytes,1,opt,name=tid,proto3" json:"tid" form:"tid" validate:"required"`
	Nid                  string   `protobuf:"bytes,2,opt,name=nid,proto3" json:"nid" form:"nid" validate:"required"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid" form:"mid"`
	Buvid                string   `protobuf:"bytes,4,opt,name=buvid,proto3" json:"buvid" form:"buvid"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PushCallbackRequest proto.InternalMessageInfo

type UserPushDev struct {
	Id                   int64                       `protobuf:"varint,1,opt,name=id,proto3" json:"id"`
	Mid                  int64                       `protobuf:"varint,2,opt,name=mid,proto3" json:"mid" form:"mid"`
	RegisterId           string                      `protobuf:"bytes,3,opt,name=register_id,json=registerId,proto3" json:"register_id" form:"register_id"`
	Buvid                string                      `protobuf:"bytes,4,opt,name=buvid,proto3" json:"buvid" form:"buvid"`
	Sdk                  int8                        `protobuf:"varint,5,opt,name=sdk,proto3,casttype=int8" json:"sdk" form:"sdk"`
	Platform             int8                        `protobuf:"varint,6,opt,name=platform,proto3,casttype=int8" json:"platform" form:"platform"`
	State                int8                        `protobuf:"varint,7,opt,name=state,proto3,casttype=int8" json:"state" form:"state"`
	LastLoginTime        go_common_library_time.Time `protobuf:"varint,8,opt,name=last_login_time,json=lastLoginTime,proto3,casttype=go-common/library/time.Time" json:"last_login_time" form:"last_login_time"`
	Ctime                go_common_library_time.Time `protobuf:"varint,9,opt,name=ctime,proto3,casttype=go-common/library/time.Time" json:"ctime"`
	Mtime                go_common_library_time.Time `protobuf:"varint,10,opt,name=mtime,proto3,casttype=go-common/library/time.Time" json:"mtime"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_UserPushDev proto.InternalMessageInfo

func init() {
	proto.RegisterType((*GetUnreadInfoRequest)(nil), "bbq.service.notice.v1.GetUnreadInfoRequest")
	proto.RegisterType((*UnreadInfo)(nil), "bbq.service.notice.v1.UnreadInfo")
	proto.RegisterType((*UnreadItem)(nil), "bbq.service.notice.v1.UnreadItem")
	proto.RegisterType((*ListNoticesReq)(nil), "bbq.service.notice.v1.ListNoticesReq")
	proto.RegisterType((*ListNoticesReply)(nil), "bbq.service.notice.v1.ListNoticesReply")
	proto.RegisterType((*NoticeBase)(nil), "bbq.service.notice.v1.NoticeBase")
	proto.RegisterType((*CreateNoticesReq)(nil), "bbq.service.notice.v1.CreateNoticesReq")
	proto.RegisterType((*CreateNoticesReply)(nil), "bbq.service.notice.v1.CreateNoticesReply")
	proto.RegisterType((*PushCallbackRequest)(nil), "bbq.service.notice.v1.PushCallbackRequest")
	proto.RegisterType((*UserPushDev)(nil), "bbq.service.notice.v1.UserPushDev")
}

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

// NoticeClient is the client API for Notice service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NoticeClient interface {
	// 获取所有通知类型的未读数
	GetUnreadInfo(ctx context.Context, in *GetUnreadInfoRequest, opts ...grpc.CallOption) (*UnreadInfo, error)
	// 获取通知列表
	ListNotices(ctx context.Context, in *ListNoticesReq, opts ...grpc.CallOption) (*ListNoticesReply, error)
	// 批量创建消息
	CreateNotice(ctx context.Context, in *NoticeBase, opts ...grpc.CallOption) (*empty.Empty, error)
	// 推送回调
	PushCallback(ctx context.Context, in *PushCallbackRequest, opts ...grpc.CallOption) (*empty.Empty, error)
	// Push的login接口
	PushLogin(ctx context.Context, in *UserPushDev, opts ...grpc.CallOption) (*empty.Empty, error)
	// Push的logout接口
	PushLogout(ctx context.Context, in *UserPushDev, opts ...grpc.CallOption) (*empty.Empty, error)
}

type noticeClient struct {
	cc *grpc.ClientConn
}

func NewNoticeClient(cc *grpc.ClientConn) NoticeClient {
	return &noticeClient{cc}
}

func (c *noticeClient) GetUnreadInfo(ctx context.Context, in *GetUnreadInfoRequest, opts ...grpc.CallOption) (*UnreadInfo, error) {
	out := new(UnreadInfo)
	err := c.cc.Invoke(ctx, "/bbq.service.notice.v1.Notice/GetUnreadInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *noticeClient) ListNotices(ctx context.Context, in *ListNoticesReq, opts ...grpc.CallOption) (*ListNoticesReply, error) {
	out := new(ListNoticesReply)
	err := c.cc.Invoke(ctx, "/bbq.service.notice.v1.Notice/ListNotices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *noticeClient) CreateNotice(ctx context.Context, in *NoticeBase, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/bbq.service.notice.v1.Notice/CreateNotice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *noticeClient) PushCallback(ctx context.Context, in *PushCallbackRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/bbq.service.notice.v1.Notice/PushCallback", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *noticeClient) PushLogin(ctx context.Context, in *UserPushDev, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/bbq.service.notice.v1.Notice/PushLogin", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *noticeClient) PushLogout(ctx context.Context, in *UserPushDev, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/bbq.service.notice.v1.Notice/PushLogout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NoticeServer is the server API for Notice service.
type NoticeServer interface {
	// 获取所有通知类型的未读数
	GetUnreadInfo(context.Context, *GetUnreadInfoRequest) (*UnreadInfo, error)
	// 获取通知列表
	ListNotices(context.Context, *ListNoticesReq) (*ListNoticesReply, error)
	// 批量创建消息
	CreateNotice(context.Context, *NoticeBase) (*empty.Empty, error)
	// 推送回调
	PushCallback(context.Context, *PushCallbackRequest) (*empty.Empty, error)
	// Push的login接口
	PushLogin(context.Context, *UserPushDev) (*empty.Empty, error)
	// Push的logout接口
	PushLogout(context.Context, *UserPushDev) (*empty.Empty, error)
}

func RegisterNoticeServer(s *grpc.Server, srv NoticeServer) {
	s.RegisterService(&_Notice_serviceDesc, srv)
}

func _Notice_GetUnreadInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetUnreadInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NoticeServer).GetUnreadInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bbq.service.notice.v1.Notice/GetUnreadInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NoticeServer).GetUnreadInfo(ctx, req.(*GetUnreadInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Notice_ListNotices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListNoticesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NoticeServer).ListNotices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bbq.service.notice.v1.Notice/ListNotices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NoticeServer).ListNotices(ctx, req.(*ListNoticesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Notice_CreateNotice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NoticeBase)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NoticeServer).CreateNotice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bbq.service.notice.v1.Notice/CreateNotice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NoticeServer).CreateNotice(ctx, req.(*NoticeBase))
	}
	return interceptor(ctx, in, info, handler)
}

func _Notice_PushCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushCallbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NoticeServer).PushCallback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bbq.service.notice.v1.Notice/PushCallback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NoticeServer).PushCallback(ctx, req.(*PushCallbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Notice_PushLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserPushDev)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NoticeServer).PushLogin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bbq.service.notice.v1.Notice/PushLogin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NoticeServer).PushLogin(ctx, req.(*UserPushDev))
	}
	return interceptor(ctx, in, info, handler)
}

func _Notice_PushLogout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserPushDev)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NoticeServer).PushLogout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bbq.service.notice.v1.Notice/PushLogout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NoticeServer).PushLogout(ctx, req.(*UserPushDev))
	}
	return interceptor(ctx, in, info, handler)
}

var _Notice_serviceDesc = grpc.ServiceDesc{
	ServiceName: "bbq.service.notice.v1.Notice",
	HandlerType: (*NoticeServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetUnreadInfo",
			Handler:    _Notice_GetUnreadInfo_Handler,
		},
		{
			MethodName: "ListNotices",
			Handler:    _Notice_ListNotices_Handler,
		},
		{
			MethodName: "CreateNotice",
			Handler:    _Notice_CreateNotice_Handler,
		},
		{
			MethodName: "PushCallback",
			Handler:    _Notice_PushCallback_Handler,
		},
		{
			MethodName: "PushLogin",
			Handler:    _Notice_PushLogin_Handler,
		},
		{
			MethodName: "PushLogout",
			Handler:    _Notice_PushLogout_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/bbq/notice-service/api/v1/api.proto",
}

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

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

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

func (m *ListNoticesReq) 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 *ListNoticesReq) 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.NoticeType != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.NoticeType))
	}
	if m.CursorId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CursorId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ListNoticesReply) 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 *ListNoticesReply) 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.List) > 0 {
		for _, msg := range m.List {
			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
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *NoticeBase) 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 *NoticeBase) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Id))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.ActionMid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ActionMid))
	}
	if m.SvId != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.SvId))
	}
	if len(m.Title) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if len(m.Text) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Text)))
		i += copy(dAtA[i:], m.Text)
	}
	if len(m.JumpUrl) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.JumpUrl)))
		i += copy(dAtA[i:], m.JumpUrl)
	}
	if m.NoticeType != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.NoticeType))
	}
	if m.BizType != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.BizType))
	}
	if m.BizId != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.BizId))
	}
	if m.NoticeTime != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.NoticeTime))
	}
	if len(m.Buvid) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Buvid)))
		i += copy(dAtA[i:], m.Buvid)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

func (m *PushCallbackRequest) 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 *PushCallbackRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Tid) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Tid)))
		i += copy(dAtA[i:], m.Tid)
	}
	if len(m.Nid) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Nid)))
		i += copy(dAtA[i:], m.Nid)
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Buvid) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Buvid)))
		i += copy(dAtA[i:], m.Buvid)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *UserPushDev) 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 *UserPushDev) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Id))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.RegisterId) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.RegisterId)))
		i += copy(dAtA[i:], m.RegisterId)
	}
	if len(m.Buvid) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Buvid)))
		i += copy(dAtA[i:], m.Buvid)
	}
	if m.Sdk != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Sdk))
	}
	if m.Platform != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Platform))
	}
	if m.State != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.State))
	}
	if m.LastLoginTime != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.LastLoginTime))
	}
	if m.Ctime != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ctime))
	}
	if m.Mtime != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mtime))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

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

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

func (m *NoticeBase) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovApi(uint64(m.Id))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.ActionMid != 0 {
		n += 1 + sovApi(uint64(m.ActionMid))
	}
	if m.SvId != 0 {
		n += 1 + sovApi(uint64(m.SvId))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.JumpUrl)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.NoticeType != 0 {
		n += 1 + sovApi(uint64(m.NoticeType))
	}
	if m.BizType != 0 {
		n += 1 + sovApi(uint64(m.BizType))
	}
	if m.BizId != 0 {
		n += 1 + sovApi(uint64(m.BizId))
	}
	if m.NoticeTime != 0 {
		n += 1 + sovApi(uint64(m.NoticeTime))
	}
	l = len(m.Buvid)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

func (m *UserPushDev) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovApi(uint64(m.Id))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.RegisterId)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Buvid)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Sdk != 0 {
		n += 1 + sovApi(uint64(m.Sdk))
	}
	if m.Platform != 0 {
		n += 1 + sovApi(uint64(m.Platform))
	}
	if m.State != 0 {
		n += 1 + sovApi(uint64(m.State))
	}
	if m.LastLoginTime != 0 {
		n += 1 + sovApi(uint64(m.LastLoginTime))
	}
	if m.Ctime != 0 {
		n += 1 + sovApi(uint64(m.Ctime))
	}
	if m.Mtime != 0 {
		n += 1 + sovApi(uint64(m.Mtime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NoticeBase) 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: NoticeBase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NoticeBase: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActionMid", wireType)
			}
			m.ActionMid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActionMid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SvId", wireType)
			}
			m.SvId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SvId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", 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.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Text", 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.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JumpUrl", 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.JumpUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoticeType", wireType)
			}
			m.NoticeType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NoticeType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BizType", wireType)
			}
			m.BizType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BizType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BizId", wireType)
			}
			m.BizId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BizId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoticeTime", wireType)
			}
			m.NoticeTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NoticeTime |= (go_common_library_time.Time(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			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
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UserPushDev) 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: UserPushDev: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserPushDev: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterId", 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.RegisterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sdk", wireType)
			}
			m.Sdk = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sdk |= (int8(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 |= (int8(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= (int8(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastLoginTime", wireType)
			}
			m.LastLoginTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastLoginTime |= (go_common_library_time.Time(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ctime", wireType)
			}
			m.Ctime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ctime |= (go_common_library_time.Time(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mtime", wireType)
			}
			m.Mtime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mtime |= (go_common_library_time.Time(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func 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/bbq/notice-service/api/v1/api.proto", fileDescriptor_api_f3f9fadf7a218fa5)
}

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