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

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

package api

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

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 ModelPage struct {
	Num                  int32    `protobuf:"varint,1,opt,name=num,proto3" json:"num,omitempty"`
	Size_                int32    `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	Count                int32    `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelPage proto.InternalMessageInfo

func (m *ModelPage) GetNum() int32 {
	if m != nil {
		return m.Num
	}
	return 0
}

func (m *ModelPage) GetSize_() int32 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *ModelPage) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type ModelFavorite struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Oid                  int64    `protobuf:"varint,2,opt,name=oid,proto3" json:"oid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64    `protobuf:"varint,4,opt,name=fid,proto3" json:"fid,omitempty"`
	Type                 int32    `protobuf:"varint,5,opt,name=type,proto3" json:"type,omitempty"`
	State                int32    `protobuf:"varint,6,opt,name=state,proto3" json:"state,omitempty"`
	Ctime                int64    `protobuf:"varint,7,opt,name=ctime,proto3" json:"ctime,omitempty"`
	Mtime                int64    `protobuf:"varint,8,opt,name=mtime,proto3" json:"mtime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelFavorite proto.InternalMessageInfo

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

func (m *ModelFavorite) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

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

func (m *ModelFavorite) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

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

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

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

type ModelPartition struct {
	Tid                  int32    `protobuf:"varint,1,opt,name=tid,proto3" json:"tid,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Count                int32    `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModelPartition proto.InternalMessageInfo

func (m *ModelPartition) GetTid() int32 {
	if m != nil {
		return m.Tid
	}
	return 0
}

func (m *ModelPartition) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ModelPartition) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type ModelFavorites struct {
	Page                 *ModelPage       `protobuf:"bytes,1,opt,name=page" json:"page,omitempty"`
	List                 []*ModelFavorite `protobuf:"bytes,2,rep,name=list" json:"list,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_ModelFavorites proto.InternalMessageInfo

func (m *ModelFavorites) GetPage() *ModelPage {
	if m != nil {
		return m.Page
	}
	return nil
}

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

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

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

var xxx_messageInfo_AddFavReply proto.InternalMessageInfo

type AddFavReq struct {
	Tp                   int32    `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64    `protobuf:"varint,4,opt,name=fid,proto3" json:"fid,omitempty"`
	Oid                  int64    `protobuf:"varint,5,opt,name=oid,proto3" json:"oid,omitempty"`
	Otype                int32    `protobuf:"varint,6,opt,name=otype,proto3" json:"otype,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AddFavReq proto.InternalMessageInfo

func (m *AddFavReq) GetTp() int32 {
	if m != nil {
		return m.Tp
	}
	return 0
}

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

func (m *AddFavReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

func (m *AddFavReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *AddFavReq) GetOtype() int32 {
	if m != nil {
		return m.Otype
	}
	return 0
}

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

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

var xxx_messageInfo_DelFavReply proto.InternalMessageInfo

type DelFavReq struct {
	Tp                   int32    `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64    `protobuf:"varint,4,opt,name=fid,proto3" json:"fid,omitempty"`
	Oid                  int64    `protobuf:"varint,5,opt,name=oid,proto3" json:"oid,omitempty"`
	Otype                int32    `protobuf:"varint,6,opt,name=otype,proto3" json:"otype,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DelFavReq proto.InternalMessageInfo

func (m *DelFavReq) GetTp() int32 {
	if m != nil {
		return m.Tp
	}
	return 0
}

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

func (m *DelFavReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

func (m *DelFavReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *DelFavReq) GetOtype() int32 {
	if m != nil {
		return m.Otype
	}
	return 0
}

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

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

var xxx_messageInfo_FavoritesReply proto.InternalMessageInfo

func (m *FavoritesReply) GetRes() *ModelFavorites {
	if m != nil {
		return m.Res
	}
	return nil
}

type FavoritesReq struct {
	Tp                   int32    `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Uid                  int64    `protobuf:"varint,4,opt,name=uid,proto3" json:"uid,omitempty"`
	Fid                  int64    `protobuf:"varint,5,opt,name=fid,proto3" json:"fid,omitempty"`
	Pn                   int32    `protobuf:"varint,6,opt,name=pn,proto3" json:"pn,omitempty"`
	Ps                   int32    `protobuf:"varint,7,opt,name=ps,proto3" json:"ps,omitempty"`
	Tid                  int32    `protobuf:"varint,8,opt,name=tid,proto3" json:"tid,omitempty"`
	Tv                   int32    `protobuf:"varint,9,opt,name=tv,proto3" json:"tv,omitempty"`
	Keyword              string   `protobuf:"bytes,10,opt,name=keyword,proto3" json:"keyword,omitempty"`
	Order                string   `protobuf:"bytes,11,opt,name=order,proto3" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FavoritesReq proto.InternalMessageInfo

func (m *FavoritesReq) GetTp() int32 {
	if m != nil {
		return m.Tp
	}
	return 0
}

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

func (m *FavoritesReq) GetUid() int64 {
	if m != nil {
		return m.Uid
	}
	return 0
}

func (m *FavoritesReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

func (m *FavoritesReq) GetPn() int32 {
	if m != nil {
		return m.Pn
	}
	return 0
}

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

func (m *FavoritesReq) GetTid() int32 {
	if m != nil {
		return m.Tid
	}
	return 0
}

func (m *FavoritesReq) GetTv() int32 {
	if m != nil {
		return m.Tv
	}
	return 0
}

func (m *FavoritesReq) GetKeyword() string {
	if m != nil {
		return m.Keyword
	}
	return ""
}

func (m *FavoritesReq) GetOrder() string {
	if m != nil {
		return m.Order
	}
	return ""
}

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

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

var xxx_messageInfo_TlistsReply proto.InternalMessageInfo

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

type TlistsReq struct {
	Tp                   int32    `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Uid                  int64    `protobuf:"varint,4,opt,name=uid,proto3" json:"uid,omitempty"`
	Fid                  int64    `protobuf:"varint,5,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TlistsReq proto.InternalMessageInfo

func (m *TlistsReq) GetTp() int32 {
	if m != nil {
		return m.Tp
	}
	return 0
}

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

func (m *TlistsReq) GetUid() int64 {
	if m != nil {
		return m.Uid
	}
	return 0
}

func (m *TlistsReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type RecentFavsReply struct {
	Res                  []int64  `protobuf:"varint,1,rep,packed,name=res" json:"res,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecentFavsReply proto.InternalMessageInfo

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

type RecentFavsReq struct {
	Tp                   int32    `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Size_                int32    `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecentFavsReq proto.InternalMessageInfo

func (m *RecentFavsReq) GetTp() int32 {
	if m != nil {
		return m.Tp
	}
	return 0
}

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

func (m *RecentFavsReq) GetSize_() int32 {
	if m != nil {
		return m.Size_
	}
	return 0
}

type IsFavoredReply struct {
	Faved                bool     `protobuf:"varint,1,opt,name=faved,proto3" json:"faved,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IsFavoredReply proto.InternalMessageInfo

func (m *IsFavoredReply) GetFaved() bool {
	if m != nil {
		return m.Faved
	}
	return false
}

type IsFavoredReq struct {
	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Oid                  int64    `protobuf:"varint,4,opt,name=oid,proto3" json:"oid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IsFavoredReq proto.InternalMessageInfo

func (m *IsFavoredReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *IsFavoredReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

type IsFavoredByFidReq struct {
	Type                 int32    `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Oid                  int64    `protobuf:"varint,3,opt,name=oid,proto3" json:"oid,omitempty"`
	Fid                  int64    `protobuf:"varint,4,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IsFavoredByFidReq proto.InternalMessageInfo

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

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

func (m *IsFavoredByFidReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *IsFavoredByFidReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

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

var xxx_messageInfo_IsFavoredsReply proto.InternalMessageInfo

func (m *IsFavoredsReply) GetFaveds() map[int64]bool {
	if m != nil {
		return m.Faveds
	}
	return nil
}

type IsFavoredsReq struct {
	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Oids                 []int64  `protobuf:"varint,4,rep,packed,name=oids" json:"oids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IsFavoredsReq proto.InternalMessageInfo

func (m *IsFavoredsReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *IsFavoredsReq) GetOids() []int64 {
	if m != nil {
		return m.Oids
	}
	return nil
}

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

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

var xxx_messageInfo_UserFoldersReply proto.InternalMessageInfo

func (m *UserFoldersReply) GetRes() []*model.Folder {
	if m != nil {
		return m.Res
	}
	return nil
}

type UserFoldersReq struct {
	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Vmid                 int64    `protobuf:"varint,4,opt,name=vmid,proto3" json:"vmid,omitempty"`
	Oid                  int64    `protobuf:"varint,5,opt,name=oid,proto3" json:"oid,omitempty"`
	AllCount             bool     `protobuf:"varint,6,opt,name=allCount,proto3" json:"allCount,omitempty"`
	Otype                int32    `protobuf:"varint,7,opt,name=otype,proto3" json:"otype,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UserFoldersReq proto.InternalMessageInfo

func (m *UserFoldersReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *UserFoldersReq) GetVmid() int64 {
	if m != nil {
		return m.Vmid
	}
	return 0
}

func (m *UserFoldersReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *UserFoldersReq) GetAllCount() bool {
	if m != nil {
		return m.AllCount
	}
	return false
}

func (m *UserFoldersReq) GetOtype() int32 {
	if m != nil {
		return m.Otype
	}
	return 0
}

type UserFolderReply struct {
	Res                  *model.Folder `protobuf:"bytes,1,opt,name=res" json:"res,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_UserFolderReply proto.InternalMessageInfo

func (m *UserFolderReply) GetRes() *model.Folder {
	if m != nil {
		return m.Res
	}
	return nil
}

type UserFolderReq struct {
	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Vmid                 int64    `protobuf:"varint,4,opt,name=vmid,proto3" json:"vmid,omitempty"`
	Fid                  int64    `protobuf:"varint,5,opt,name=fid,proto3" json:"fid,omitempty"`
	AllCount             bool     `protobuf:"varint,6,opt,name=allCount,proto3" json:"allCount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UserFolderReq proto.InternalMessageInfo

func (m *UserFolderReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *UserFolderReq) GetVmid() int64 {
	if m != nil {
		return m.Vmid
	}
	return 0
}

func (m *UserFolderReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

func (m *UserFolderReq) GetAllCount() bool {
	if m != nil {
		return m.AllCount
	}
	return false
}

type AddFolderReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Description          string   `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	Cover                string   `protobuf:"bytes,5,opt,name=cover,proto3" json:"cover,omitempty"`
	Public               int32    `protobuf:"varint,6,opt,name=public,proto3" json:"public,omitempty"`
	Cookie               string   `protobuf:"bytes,7,opt,name=cookie,proto3" json:"cookie,omitempty"`
	AccessKey            string   `protobuf:"bytes,8,opt,name=accessKey,proto3" json:"accessKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AddFolderReq proto.InternalMessageInfo

func (m *AddFolderReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *AddFolderReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AddFolderReq) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *AddFolderReq) GetCover() string {
	if m != nil {
		return m.Cover
	}
	return ""
}

func (m *AddFolderReq) GetPublic() int32 {
	if m != nil {
		return m.Public
	}
	return 0
}

func (m *AddFolderReq) GetCookie() string {
	if m != nil {
		return m.Cookie
	}
	return ""
}

func (m *AddFolderReq) GetAccessKey() string {
	if m != nil {
		return m.AccessKey
	}
	return ""
}

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

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

var xxx_messageInfo_AddFolderReply proto.InternalMessageInfo

func (m *AddFolderReply) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type UpdateFolderReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Fid                  int64    `protobuf:"varint,2,opt,name=fid,proto3" json:"fid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Name                 string   `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	Description          string   `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	Cover                string   `protobuf:"bytes,6,opt,name=cover,proto3" json:"cover,omitempty"`
	Public               int32    `protobuf:"varint,7,opt,name=public,proto3" json:"public,omitempty"`
	Cookie               string   `protobuf:"bytes,8,opt,name=cookie,proto3" json:"cookie,omitempty"`
	AccessKey            string   `protobuf:"bytes,9,opt,name=accessKey,proto3" json:"accessKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpdateFolderReq proto.InternalMessageInfo

func (m *UpdateFolderReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *UpdateFolderReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

func (m *UpdateFolderReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UpdateFolderReq) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *UpdateFolderReq) GetCover() string {
	if m != nil {
		return m.Cover
	}
	return ""
}

func (m *UpdateFolderReq) GetPublic() int32 {
	if m != nil {
		return m.Public
	}
	return 0
}

func (m *UpdateFolderReq) GetCookie() string {
	if m != nil {
		return m.Cookie
	}
	return ""
}

func (m *UpdateFolderReq) GetAccessKey() string {
	if m != nil {
		return m.AccessKey
	}
	return ""
}

type AdminUpdateFolderReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Fid                  int64    `protobuf:"varint,2,opt,name=fid,proto3" json:"fid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Name                 string   `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	Description          string   `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	Cover                string   `protobuf:"bytes,6,opt,name=cover,proto3" json:"cover,omitempty"`
	State                int32    `protobuf:"varint,7,opt,name=state,proto3" json:"state,omitempty"`
	Attr                 int32    `protobuf:"varint,8,opt,name=attr,proto3" json:"attr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AdminUpdateFolderReq proto.InternalMessageInfo

func (m *AdminUpdateFolderReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *AdminUpdateFolderReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

func (m *AdminUpdateFolderReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AdminUpdateFolderReq) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *AdminUpdateFolderReq) GetCover() string {
	if m != nil {
		return m.Cover
	}
	return ""
}

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

func (m *AdminUpdateFolderReq) GetAttr() int32 {
	if m != nil {
		return m.Attr
	}
	return 0
}

type DelFolderReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64    `protobuf:"varint,3,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DelFolderReq proto.InternalMessageInfo

func (m *DelFolderReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *DelFolderReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type MultiAddReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Oids                 []int64  `protobuf:"varint,3,rep,packed,name=oids" json:"oids,omitempty"`
	Fid                  int64    `protobuf:"varint,4,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MultiAddReq proto.InternalMessageInfo

func (m *MultiAddReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *MultiAddReq) GetOids() []int64 {
	if m != nil {
		return m.Oids
	}
	return nil
}

func (m *MultiAddReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type MultiDelReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Oids                 []int64  `protobuf:"varint,3,rep,packed,name=oids" json:"oids,omitempty"`
	Fid                  int64    `protobuf:"varint,4,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MultiDelReq proto.InternalMessageInfo

func (m *MultiDelReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *MultiDelReq) GetOids() []int64 {
	if m != nil {
		return m.Oids
	}
	return nil
}

func (m *MultiDelReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type InDefaultFolderReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Oid                  int64    `protobuf:"varint,3,opt,name=oid,proto3" json:"oid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InDefaultFolderReq proto.InternalMessageInfo

func (m *InDefaultFolderReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *InDefaultFolderReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

type InDefaultFolderReply struct {
	IsIn                 bool     `protobuf:"varint,1,opt,name=isIn,proto3" json:"isIn,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InDefaultFolderReply proto.InternalMessageInfo

func (m *InDefaultFolderReply) GetIsIn() bool {
	if m != nil {
		return m.IsIn
	}
	return false
}

type CntUserFoldersReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Vmid                 int64    `protobuf:"varint,3,opt,name=vmid,proto3" json:"vmid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CntUserFoldersReq proto.InternalMessageInfo

func (m *CntUserFoldersReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *CntUserFoldersReq) GetVmid() int64 {
	if m != nil {
		return m.Vmid
	}
	return 0
}

type CntUserFoldersReply struct {
	Count                int32    `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CntUserFoldersReply proto.InternalMessageInfo

func (m *CntUserFoldersReply) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type User struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Oid                  int64    `protobuf:"varint,2,opt,name=oid,proto3" json:"oid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Typ                  int32    `protobuf:"varint,4,opt,name=typ,proto3" json:"typ,omitempty"`
	State                int32    `protobuf:"varint,5,opt,name=state,proto3" json:"state,omitempty"`
	Ctime                int64    `protobuf:"varint,6,opt,name=ctime,proto3" json:"ctime,omitempty"`
	Mtime                int64    `protobuf:"varint,7,opt,name=mtime,proto3" json:"mtime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_User proto.InternalMessageInfo

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

func (m *User) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

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

func (m *User) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

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

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

type FavedUsersReply struct {
	Page                 *ModelPage `protobuf:"bytes,1,opt,name=page" json:"page,omitempty"`
	User                 []*User    `protobuf:"bytes,2,rep,name=user" json:"user,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_FavedUsersReply proto.InternalMessageInfo

func (m *FavedUsersReply) GetPage() *ModelPage {
	if m != nil {
		return m.Page
	}
	return nil
}

func (m *FavedUsersReply) GetUser() []*User {
	if m != nil {
		return m.User
	}
	return nil
}

type FavedUsersReq struct {
	Type                 int32    `protobuf:"varint,1,opt,name=Type,proto3" json:"Type,omitempty"`
	Oid                  int64    `protobuf:"varint,2,opt,name=Oid,proto3" json:"Oid,omitempty"`
	Pn                   int32    `protobuf:"varint,3,opt,name=pn,proto3" json:"pn,omitempty"`
	Ps                   int32    `protobuf:"varint,4,opt,name=ps,proto3" json:"ps,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FavedUsersReq proto.InternalMessageInfo

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

func (m *FavedUsersReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *FavedUsersReq) GetPn() int32 {
	if m != nil {
		return m.Pn
	}
	return 0
}

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

type SetFolderSortReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Fids                 []int64  `protobuf:"varint,4,rep,packed,name=fids" json:"fids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SetFolderSortReq proto.InternalMessageInfo

func (m *SetFolderSortReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *SetFolderSortReq) GetFids() []int64 {
	if m != nil {
		return m.Fids
	}
	return nil
}

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

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

var xxx_messageInfo_FoldersReply proto.InternalMessageInfo

func (m *FoldersReply) GetRes() []*model.Folder {
	if m != nil {
		return m.Res
	}
	return nil
}

type FoldersReq struct {
	// id = fid*100 + mid%100
	Ids                  []*FolderID `protobuf:"bytes,1,rep,name=ids" json:"ids,omitempty"`
	Typ                  int32       `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64       `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_FoldersReq proto.InternalMessageInfo

func (m *FoldersReq) GetIds() []*FolderID {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *FoldersReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

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

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

var xxx_messageInfo_FolderID proto.InternalMessageInfo

func (m *FolderID) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

type MoveFavsReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	OldFid               int64    `protobuf:"varint,3,opt,name=oldFid,proto3" json:"oldFid,omitempty"`
	NewFid               int64    `protobuf:"varint,4,opt,name=newFid,proto3" json:"newFid,omitempty"`
	Oids                 []int64  `protobuf:"varint,5,rep,packed,name=oids" json:"oids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MoveFavsReq proto.InternalMessageInfo

func (m *MoveFavsReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *MoveFavsReq) GetOldFid() int64 {
	if m != nil {
		return m.OldFid
	}
	return 0
}

func (m *MoveFavsReq) GetNewFid() int64 {
	if m != nil {
		return m.NewFid
	}
	return 0
}

func (m *MoveFavsReq) GetOids() []int64 {
	if m != nil {
		return m.Oids
	}
	return nil
}

type CopyFavsReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	OldMid               int64    `protobuf:"varint,2,opt,name=oldMid,proto3" json:"oldMid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	OldFid               int64    `protobuf:"varint,4,opt,name=oldFid,proto3" json:"oldFid,omitempty"`
	NewFid               int64    `protobuf:"varint,5,opt,name=newFid,proto3" json:"newFid,omitempty"`
	Oids                 []int64  `protobuf:"varint,6,rep,packed,name=oids" json:"oids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CopyFavsReq proto.InternalMessageInfo

func (m *CopyFavsReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *CopyFavsReq) GetOldMid() int64 {
	if m != nil {
		return m.OldMid
	}
	return 0
}

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

func (m *CopyFavsReq) GetOldFid() int64 {
	if m != nil {
		return m.OldFid
	}
	return 0
}

func (m *CopyFavsReq) GetNewFid() int64 {
	if m != nil {
		return m.NewFid
	}
	return 0
}

func (m *CopyFavsReq) GetOids() []int64 {
	if m != nil {
		return m.Oids
	}
	return nil
}

type CleanStateReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64    `protobuf:"varint,3,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CleanStateReq proto.InternalMessageInfo

func (m *CleanStateReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *CleanStateReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type CleanStateReply struct {
	CleanState           int32    `protobuf:"varint,1,opt,name=cleanState,proto3" json:"cleanState,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CleanStateReply proto.InternalMessageInfo

func (m *CleanStateReply) GetCleanState() int32 {
	if m != nil {
		return m.CleanState
	}
	return 0
}

type CleanInvalidFavsReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Mid                  int64    `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64    `protobuf:"varint,3,opt,name=fid,proto3" json:"fid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CleanInvalidFavsReq proto.InternalMessageInfo

func (m *CleanInvalidFavsReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

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

func (m *CleanInvalidFavsReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

type FavAddFoldersReq struct {
	Oid                  int64    `protobuf:"varint,1,opt,name=oid,proto3" json:"oid,omitempty"`
	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Fids                 []int64  `protobuf:"varint,3,rep,packed,name=fids" json:"fids,omitempty"`
	Mid                  int64    `protobuf:"varint,4,opt,name=mid,proto3" json:"mid,omitempty"`
	Otype                int32    `protobuf:"varint,5,opt,name=otype,proto3" json:"otype,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FavAddFoldersReq proto.InternalMessageInfo

func (m *FavAddFoldersReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *FavAddFoldersReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *FavAddFoldersReq) GetFids() []int64 {
	if m != nil {
		return m.Fids
	}
	return nil
}

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

func (m *FavAddFoldersReq) GetOtype() int32 {
	if m != nil {
		return m.Otype
	}
	return 0
}

type FavDelFoldersReq struct {
	Oid                  int64    `protobuf:"varint,1,opt,name=oid,proto3" json:"oid,omitempty"`
	Typ                  int32    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Fids                 []int64  `protobuf:"varint,3,rep,packed,name=fids" json:"fids,omitempty"`
	Mid                  int64    `protobuf:"varint,4,opt,name=mid,proto3" json:"mid,omitempty"`
	Otype                int32    `protobuf:"varint,5,opt,name=otype,proto3" json:"otype,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FavDelFoldersReq proto.InternalMessageInfo

func (m *FavDelFoldersReq) GetOid() int64 {
	if m != nil {
		return m.Oid
	}
	return 0
}

func (m *FavDelFoldersReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *FavDelFoldersReq) GetFids() []int64 {
	if m != nil {
		return m.Fids
	}
	return nil
}

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

func (m *FavDelFoldersReq) GetOtype() int32 {
	if m != nil {
		return m.Otype
	}
	return 0
}

type SortFavsReq struct {
	Sorts                []*SortFav `protobuf:"bytes,1,rep,name=sorts" json:"sorts,omitempty"`
	Mid                  int64      `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"`
	Fid                  int64      `protobuf:"varint,3,opt,name=fid,proto3" json:"fid,omitempty"`
	Typ                  int32      `protobuf:"varint,4,opt,name=typ,proto3" json:"typ,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_SortFavsReq proto.InternalMessageInfo

func (m *SortFavsReq) GetSorts() []*SortFav {
	if m != nil {
		return m.Sorts
	}
	return nil
}

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

func (m *SortFavsReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

func (m *SortFavsReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

type SortFav struct {
	Pre                  *model.Resource `protobuf:"bytes,1,opt,name=pre" json:"pre,omitempty"`
	Insert               *model.Resource `protobuf:"bytes,2,opt,name=insert" json:"insert,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_SortFav proto.InternalMessageInfo

func (m *SortFav) GetPre() *model.Resource {
	if m != nil {
		return m.Pre
	}
	return nil
}

func (m *SortFav) GetInsert() *model.Resource {
	if m != nil {
		return m.Insert
	}
	return nil
}

type UpFolderNameReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Fid                  int64    `protobuf:"varint,2,opt,name=fid,proto3" json:"fid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Name                 string   `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	Cookie               string   `protobuf:"bytes,5,opt,name=cookie,proto3" json:"cookie,omitempty"`
	AccessKey            string   `protobuf:"bytes,6,opt,name=accessKey,proto3" json:"accessKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpFolderNameReq proto.InternalMessageInfo

func (m *UpFolderNameReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *UpFolderNameReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

func (m *UpFolderNameReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UpFolderNameReq) GetCookie() string {
	if m != nil {
		return m.Cookie
	}
	return ""
}

func (m *UpFolderNameReq) GetAccessKey() string {
	if m != nil {
		return m.AccessKey
	}
	return ""
}

type UpFolderAttrReq struct {
	Typ                  int32    `protobuf:"varint,1,opt,name=typ,proto3" json:"typ,omitempty"`
	Fid                  int64    `protobuf:"varint,2,opt,name=fid,proto3" json:"fid,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Public               int32    `protobuf:"varint,4,opt,name=public,proto3" json:"public,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UpFolderAttrReq proto.InternalMessageInfo

func (m *UpFolderAttrReq) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *UpFolderAttrReq) GetFid() int64 {
	if m != nil {
		return m.Fid
	}
	return 0
}

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

func (m *UpFolderAttrReq) GetPublic() int32 {
	if m != nil {
		return m.Public
	}
	return 0
}

type RecentResourcesReq struct {
	Tp                   int32    `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"`
	Mid                  int64    `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"`
	Size_                int32    `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecentResourcesReq proto.InternalMessageInfo

func (m *RecentResourcesReq) GetTp() int32 {
	if m != nil {
		return m.Tp
	}
	return 0
}

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

func (m *RecentResourcesReq) GetSize_() int32 {
	if m != nil {
		return m.Size_
	}
	return 0
}

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

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

var xxx_messageInfo_RecentResourcesReply proto.InternalMessageInfo

func (m *RecentResourcesReply) GetRes() []*model.Resource {
	if m != nil {
		return m.Res
	}
	return nil
}

func init() {
	proto.RegisterType((*ModelPage)(nil), "community.service.favorite.ModelPage")
	proto.RegisterType((*ModelFavorite)(nil), "community.service.favorite.ModelFavorite")
	proto.RegisterType((*ModelPartition)(nil), "community.service.favorite.ModelPartition")
	proto.RegisterType((*ModelFavorites)(nil), "community.service.favorite.ModelFavorites")
	proto.RegisterType((*AddFavReply)(nil), "community.service.favorite.AddFavReply")
	proto.RegisterType((*AddFavReq)(nil), "community.service.favorite.AddFavReq")
	proto.RegisterType((*DelFavReply)(nil), "community.service.favorite.DelFavReply")
	proto.RegisterType((*DelFavReq)(nil), "community.service.favorite.DelFavReq")
	proto.RegisterType((*FavoritesReply)(nil), "community.service.favorite.FavoritesReply")
	proto.RegisterType((*FavoritesReq)(nil), "community.service.favorite.FavoritesReq")
	proto.RegisterType((*TlistsReply)(nil), "community.service.favorite.TlistsReply")
	proto.RegisterType((*TlistsReq)(nil), "community.service.favorite.TlistsReq")
	proto.RegisterType((*RecentFavsReply)(nil), "community.service.favorite.RecentFavsReply")
	proto.RegisterType((*RecentFavsReq)(nil), "community.service.favorite.RecentFavsReq")
	proto.RegisterType((*IsFavoredReply)(nil), "community.service.favorite.IsFavoredReply")
	proto.RegisterType((*IsFavoredReq)(nil), "community.service.favorite.IsFavoredReq")
	proto.RegisterType((*IsFavoredByFidReq)(nil), "community.service.favorite.IsFavoredByFidReq")
	proto.RegisterType((*IsFavoredsReply)(nil), "community.service.favorite.IsFavoredsReply")
	proto.RegisterMapType((map[int64]bool)(nil), "community.service.favorite.IsFavoredsReply.FavedsEntry")
	proto.RegisterType((*IsFavoredsReq)(nil), "community.service.favorite.IsFavoredsReq")
	proto.RegisterType((*UserFoldersReply)(nil), "community.service.favorite.UserFoldersReply")
	proto.RegisterType((*UserFoldersReq)(nil), "community.service.favorite.UserFoldersReq")
	proto.RegisterType((*UserFolderReply)(nil), "community.service.favorite.UserFolderReply")
	proto.RegisterType((*UserFolderReq)(nil), "community.service.favorite.UserFolderReq")
	proto.RegisterType((*AddFolderReq)(nil), "community.service.favorite.AddFolderReq")
	proto.RegisterType((*AddFolderReply)(nil), "community.service.favorite.AddFolderReply")
	proto.RegisterType((*UpdateFolderReq)(nil), "community.service.favorite.UpdateFolderReq")
	proto.RegisterType((*AdminUpdateFolderReq)(nil), "community.service.favorite.AdminUpdateFolderReq")
	proto.RegisterType((*DelFolderReq)(nil), "community.service.favorite.DelFolderReq")
	proto.RegisterType((*MultiAddReq)(nil), "community.service.favorite.MultiAddReq")
	proto.RegisterType((*MultiDelReq)(nil), "community.service.favorite.MultiDelReq")
	proto.RegisterType((*InDefaultFolderReq)(nil), "community.service.favorite.InDefaultFolderReq")
	proto.RegisterType((*InDefaultFolderReply)(nil), "community.service.favorite.InDefaultFolderReply")
	proto.RegisterType((*CntUserFoldersReq)(nil), "community.service.favorite.CntUserFoldersReq")
	proto.RegisterType((*CntUserFoldersReply)(nil), "community.service.favorite.CntUserFoldersReply")
	proto.RegisterType((*User)(nil), "community.service.favorite.User")
	proto.RegisterType((*FavedUsersReply)(nil), "community.service.favorite.FavedUsersReply")
	proto.RegisterType((*FavedUsersReq)(nil), "community.service.favorite.FavedUsersReq")
	proto.RegisterType((*SetFolderSortReq)(nil), "community.service.favorite.SetFolderSortReq")
	proto.RegisterType((*FoldersReply)(nil), "community.service.favorite.FoldersReply")
	proto.RegisterType((*FoldersReq)(nil), "community.service.favorite.FoldersReq")
	proto.RegisterType((*FolderID)(nil), "community.service.favorite.FolderID")
	proto.RegisterType((*MoveFavsReq)(nil), "community.service.favorite.MoveFavsReq")
	proto.RegisterType((*CopyFavsReq)(nil), "community.service.favorite.CopyFavsReq")
	proto.RegisterType((*CleanStateReq)(nil), "community.service.favorite.CleanStateReq")
	proto.RegisterType((*CleanStateReply)(nil), "community.service.favorite.CleanStateReply")
	proto.RegisterType((*CleanInvalidFavsReq)(nil), "community.service.favorite.CleanInvalidFavsReq")
	proto.RegisterType((*FavAddFoldersReq)(nil), "community.service.favorite.FavAddFoldersReq")
	proto.RegisterType((*FavDelFoldersReq)(nil), "community.service.favorite.FavDelFoldersReq")
	proto.RegisterType((*SortFavsReq)(nil), "community.service.favorite.SortFavsReq")
	proto.RegisterType((*SortFav)(nil), "community.service.favorite.SortFav")
	proto.RegisterType((*UpFolderNameReq)(nil), "community.service.favorite.UpFolderNameReq")
	proto.RegisterType((*UpFolderAttrReq)(nil), "community.service.favorite.UpFolderAttrReq")
	proto.RegisterType((*RecentResourcesReq)(nil), "community.service.favorite.RecentResourcesReq")
	proto.RegisterType((*RecentResourcesReply)(nil), "community.service.favorite.RecentResourcesReply")
}

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

type FavoriteClient interface {
	// 更新收藏夹V2版本
	AdminUpdateFolder(ctx context.Context, in *AdminUpdateFolderReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 删除一个资源从多个收藏夹
	FavDelFolders(ctx context.Context, in *FavDelFoldersReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 添加一个资源至多个收藏夹
	FavAddFolders(ctx context.Context, in *FavAddFoldersReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 收藏夹重命名
	UpFolderName(ctx context.Context, in *UpFolderNameReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 设置收藏夹公开
	UpFolderAttr(ctx context.Context, in *UpFolderAttrReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 清除不合法的收藏资源
	CleanInvalidFavs(ctx context.Context, in *CleanInvalidFavsReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 返回某个收藏夹是否已经是clean的
	CleanState(ctx context.Context, in *CleanStateReq, opts ...grpc.CallOption) (*CleanStateReply, error)
	// 拷贝收藏夹内的资源至另外一个收藏夹
	CopyFavs(ctx context.Context, in *CopyFavsReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 移动收藏夹内的资源至另外一个收藏夹
	MoveFavs(ctx context.Context, in *MoveFavsReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 收藏夹排序
	SetFolderSort(ctx context.Context, in *SetFolderSortReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 哪些用户收藏了该资源
	FavedUsers(ctx context.Context, in *FavedUsersReq, opts ...grpc.CallOption) (*FavedUsersReply, error)
	// 用户收藏夹数量
	CntUserFolders(ctx context.Context, in *CntUserFoldersReq, opts ...grpc.CallOption) (*CntUserFoldersReply, error)
	// 该资源是否在默认收藏夹中
	InDefault(ctx context.Context, in *InDefaultFolderReq, opts ...grpc.CallOption) (*InDefaultFolderReply, error)
	// 批量删除多个资源
	MultiDel(ctx context.Context, in *MultiDelReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 批量添加多个资源
	MultiAdd(ctx context.Context, in *MultiAddReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 删除收藏夹
	DelFolder(ctx context.Context, in *DelFolderReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 更新收藏夹
	UpdateFolder(ctx context.Context, in *UpdateFolderReq, opts ...grpc.CallOption) (*empty.Empty, error)
	// 创建收藏夹
	AddFolder(ctx context.Context, in *AddFolderReq, opts ...grpc.CallOption) (*AddFolderReply, error)
	// 收藏夹内的资源列表(只显示和收藏夹相同type的资源)
	Favorites(ctx context.Context, in *FavoritesReq, opts ...grpc.CallOption) (*FavoritesReply, error)
	// 收藏夹内的资源列表(显示所有资源)
	FavoritesAll(ctx context.Context, in *FavoritesReq, opts ...grpc.CallOption) (*FavoritesReply, error)
	// 分区信息
	Tlists(ctx context.Context, in *TlistsReq, opts ...grpc.CallOption) (*TlistsReply, error)
	// 该用户最近收藏
	RecentFavs(ctx context.Context, in *RecentFavsReq, opts ...grpc.CallOption) (*RecentFavsReply, error)
	// 该用户最近收藏的资源
	RecentResources(ctx context.Context, in *RecentResourcesReq, opts ...grpc.CallOption) (*RecentResourcesReply, error)
	// 用户是否收藏该资源
	IsFavored(ctx context.Context, in *IsFavoredReq, opts ...grpc.CallOption) (*IsFavoredReply, error)
	// 该资源是否在某个收藏夹内
	IsFavoredByFid(ctx context.Context, in *IsFavoredByFidReq, opts ...grpc.CallOption) (*IsFavoredReply, error)
	// 多个资源是否被用户收藏
	IsFavoreds(ctx context.Context, in *IsFavoredsReq, opts ...grpc.CallOption) (*IsFavoredsReply, error)
	// 添加收藏
	AddFav(ctx context.Context, in *AddFavReq, opts ...grpc.CallOption) (*AddFavReply, error)
	// 删除收藏
	DelFav(ctx context.Context, in *DelFavReq, opts ...grpc.CallOption) (*DelFavReply, error)
	// 用户的收藏夹列表
	UserFolders(ctx context.Context, in *UserFoldersReq, opts ...grpc.CallOption) (*UserFoldersReply, error)
	// 用户的一个收藏夹
	UserFolder(ctx context.Context, in *UserFolderReq, opts ...grpc.CallOption) (*UserFolderReply, error)
	// 通过ID批量返回收藏夹 id = fid*100 + mid%100
	Folders(ctx context.Context, in *FoldersReq, opts ...grpc.CallOption) (*FoldersReply, error)
	// 改变被搜藏的元素的顺序
	SortFavs(ctx context.Context, in *SortFavsReq, opts ...grpc.CallOption) (*empty.Empty, error)
}

type favoriteClient struct {
	cc *grpc.ClientConn
}

func NewFavoriteClient(cc *grpc.ClientConn) FavoriteClient {
	return &favoriteClient{cc}
}

func (c *favoriteClient) AdminUpdateFolder(ctx context.Context, in *AdminUpdateFolderReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/AdminUpdateFolder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) FavDelFolders(ctx context.Context, in *FavDelFoldersReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/FavDelFolders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) FavAddFolders(ctx context.Context, in *FavAddFoldersReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/FavAddFolders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) UpFolderName(ctx context.Context, in *UpFolderNameReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/UpFolderName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) UpFolderAttr(ctx context.Context, in *UpFolderAttrReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/UpFolderAttr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) CleanInvalidFavs(ctx context.Context, in *CleanInvalidFavsReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/CleanInvalidFavs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) CleanState(ctx context.Context, in *CleanStateReq, opts ...grpc.CallOption) (*CleanStateReply, error) {
	out := new(CleanStateReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/CleanState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) CopyFavs(ctx context.Context, in *CopyFavsReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/CopyFavs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) MoveFavs(ctx context.Context, in *MoveFavsReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/MoveFavs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) SetFolderSort(ctx context.Context, in *SetFolderSortReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/SetFolderSort", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) FavedUsers(ctx context.Context, in *FavedUsersReq, opts ...grpc.CallOption) (*FavedUsersReply, error) {
	out := new(FavedUsersReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/FavedUsers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) CntUserFolders(ctx context.Context, in *CntUserFoldersReq, opts ...grpc.CallOption) (*CntUserFoldersReply, error) {
	out := new(CntUserFoldersReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/CntUserFolders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) InDefault(ctx context.Context, in *InDefaultFolderReq, opts ...grpc.CallOption) (*InDefaultFolderReply, error) {
	out := new(InDefaultFolderReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/InDefault", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) MultiDel(ctx context.Context, in *MultiDelReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/MultiDel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) MultiAdd(ctx context.Context, in *MultiAddReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/MultiAdd", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) DelFolder(ctx context.Context, in *DelFolderReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/DelFolder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) UpdateFolder(ctx context.Context, in *UpdateFolderReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/UpdateFolder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) AddFolder(ctx context.Context, in *AddFolderReq, opts ...grpc.CallOption) (*AddFolderReply, error) {
	out := new(AddFolderReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/AddFolder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) Favorites(ctx context.Context, in *FavoritesReq, opts ...grpc.CallOption) (*FavoritesReply, error) {
	out := new(FavoritesReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/Favorites", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) FavoritesAll(ctx context.Context, in *FavoritesReq, opts ...grpc.CallOption) (*FavoritesReply, error) {
	out := new(FavoritesReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/FavoritesAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) Tlists(ctx context.Context, in *TlistsReq, opts ...grpc.CallOption) (*TlistsReply, error) {
	out := new(TlistsReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/Tlists", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) RecentFavs(ctx context.Context, in *RecentFavsReq, opts ...grpc.CallOption) (*RecentFavsReply, error) {
	out := new(RecentFavsReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/RecentFavs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) RecentResources(ctx context.Context, in *RecentResourcesReq, opts ...grpc.CallOption) (*RecentResourcesReply, error) {
	out := new(RecentResourcesReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/RecentResources", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) IsFavored(ctx context.Context, in *IsFavoredReq, opts ...grpc.CallOption) (*IsFavoredReply, error) {
	out := new(IsFavoredReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/IsFavored", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) IsFavoredByFid(ctx context.Context, in *IsFavoredByFidReq, opts ...grpc.CallOption) (*IsFavoredReply, error) {
	out := new(IsFavoredReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/IsFavoredByFid", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) IsFavoreds(ctx context.Context, in *IsFavoredsReq, opts ...grpc.CallOption) (*IsFavoredsReply, error) {
	out := new(IsFavoredsReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/IsFavoreds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) AddFav(ctx context.Context, in *AddFavReq, opts ...grpc.CallOption) (*AddFavReply, error) {
	out := new(AddFavReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/AddFav", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) DelFav(ctx context.Context, in *DelFavReq, opts ...grpc.CallOption) (*DelFavReply, error) {
	out := new(DelFavReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/DelFav", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) UserFolders(ctx context.Context, in *UserFoldersReq, opts ...grpc.CallOption) (*UserFoldersReply, error) {
	out := new(UserFoldersReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/UserFolders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) UserFolder(ctx context.Context, in *UserFolderReq, opts ...grpc.CallOption) (*UserFolderReply, error) {
	out := new(UserFolderReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/UserFolder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) Folders(ctx context.Context, in *FoldersReq, opts ...grpc.CallOption) (*FoldersReply, error) {
	out := new(FoldersReply)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/Folders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *favoriteClient) SortFavs(ctx context.Context, in *SortFavsReq, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/community.service.favorite.Favorite/SortFavs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Favorite service

type FavoriteServer interface {
	// 更新收藏夹V2版本
	AdminUpdateFolder(context.Context, *AdminUpdateFolderReq) (*empty.Empty, error)
	// 删除一个资源从多个收藏夹
	FavDelFolders(context.Context, *FavDelFoldersReq) (*empty.Empty, error)
	// 添加一个资源至多个收藏夹
	FavAddFolders(context.Context, *FavAddFoldersReq) (*empty.Empty, error)
	// 收藏夹重命名
	UpFolderName(context.Context, *UpFolderNameReq) (*empty.Empty, error)
	// 设置收藏夹公开
	UpFolderAttr(context.Context, *UpFolderAttrReq) (*empty.Empty, error)
	// 清除不合法的收藏资源
	CleanInvalidFavs(context.Context, *CleanInvalidFavsReq) (*empty.Empty, error)
	// 返回某个收藏夹是否已经是clean的
	CleanState(context.Context, *CleanStateReq) (*CleanStateReply, error)
	// 拷贝收藏夹内的资源至另外一个收藏夹
	CopyFavs(context.Context, *CopyFavsReq) (*empty.Empty, error)
	// 移动收藏夹内的资源至另外一个收藏夹
	MoveFavs(context.Context, *MoveFavsReq) (*empty.Empty, error)
	// 收藏夹排序
	SetFolderSort(context.Context, *SetFolderSortReq) (*empty.Empty, error)
	// 哪些用户收藏了该资源
	FavedUsers(context.Context, *FavedUsersReq) (*FavedUsersReply, error)
	// 用户收藏夹数量
	CntUserFolders(context.Context, *CntUserFoldersReq) (*CntUserFoldersReply, error)
	// 该资源是否在默认收藏夹中
	InDefault(context.Context, *InDefaultFolderReq) (*InDefaultFolderReply, error)
	// 批量删除多个资源
	MultiDel(context.Context, *MultiDelReq) (*empty.Empty, error)
	// 批量添加多个资源
	MultiAdd(context.Context, *MultiAddReq) (*empty.Empty, error)
	// 删除收藏夹
	DelFolder(context.Context, *DelFolderReq) (*empty.Empty, error)
	// 更新收藏夹
	UpdateFolder(context.Context, *UpdateFolderReq) (*empty.Empty, error)
	// 创建收藏夹
	AddFolder(context.Context, *AddFolderReq) (*AddFolderReply, error)
	// 收藏夹内的资源列表(只显示和收藏夹相同type的资源)
	Favorites(context.Context, *FavoritesReq) (*FavoritesReply, error)
	// 收藏夹内的资源列表(显示所有资源)
	FavoritesAll(context.Context, *FavoritesReq) (*FavoritesReply, error)
	// 分区信息
	Tlists(context.Context, *TlistsReq) (*TlistsReply, error)
	// 该用户最近收藏
	RecentFavs(context.Context, *RecentFavsReq) (*RecentFavsReply, error)
	// 该用户最近收藏的资源
	RecentResources(context.Context, *RecentResourcesReq) (*RecentResourcesReply, error)
	// 用户是否收藏该资源
	IsFavored(context.Context, *IsFavoredReq) (*IsFavoredReply, error)
	// 该资源是否在某个收藏夹内
	IsFavoredByFid(context.Context, *IsFavoredByFidReq) (*IsFavoredReply, error)
	// 多个资源是否被用户收藏
	IsFavoreds(context.Context, *IsFavoredsReq) (*IsFavoredsReply, error)
	// 添加收藏
	AddFav(context.Context, *AddFavReq) (*AddFavReply, error)
	// 删除收藏
	DelFav(context.Context, *DelFavReq) (*DelFavReply, error)
	// 用户的收藏夹列表
	UserFolders(context.Context, *UserFoldersReq) (*UserFoldersReply, error)
	// 用户的一个收藏夹
	UserFolder(context.Context, *UserFolderReq) (*UserFolderReply, error)
	// 通过ID批量返回收藏夹 id = fid*100 + mid%100
	Folders(context.Context, *FoldersReq) (*FoldersReply, error)
	// 改变被搜藏的元素的顺序
	SortFavs(context.Context, *SortFavsReq) (*empty.Empty, error)
}

func RegisterFavoriteServer(s *grpc.Server, srv FavoriteServer) {
	s.RegisterService(&_Favorite_serviceDesc, srv)
}

func _Favorite_AdminUpdateFolder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminUpdateFolderReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).AdminUpdateFolder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/AdminUpdateFolder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).AdminUpdateFolder(ctx, req.(*AdminUpdateFolderReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_FavDelFolders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FavDelFoldersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).FavDelFolders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/FavDelFolders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).FavDelFolders(ctx, req.(*FavDelFoldersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_FavAddFolders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FavAddFoldersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).FavAddFolders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/FavAddFolders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).FavAddFolders(ctx, req.(*FavAddFoldersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_UpFolderName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpFolderNameReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).UpFolderName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/UpFolderName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).UpFolderName(ctx, req.(*UpFolderNameReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_UpFolderAttr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpFolderAttrReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).UpFolderAttr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/UpFolderAttr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).UpFolderAttr(ctx, req.(*UpFolderAttrReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_CleanInvalidFavs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CleanInvalidFavsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).CleanInvalidFavs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/CleanInvalidFavs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).CleanInvalidFavs(ctx, req.(*CleanInvalidFavsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_CleanState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CleanStateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).CleanState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/CleanState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).CleanState(ctx, req.(*CleanStateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_CopyFavs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CopyFavsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).CopyFavs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/CopyFavs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).CopyFavs(ctx, req.(*CopyFavsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_MoveFavs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MoveFavsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).MoveFavs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/MoveFavs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).MoveFavs(ctx, req.(*MoveFavsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_SetFolderSort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetFolderSortReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).SetFolderSort(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/SetFolderSort",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).SetFolderSort(ctx, req.(*SetFolderSortReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_FavedUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FavedUsersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).FavedUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/FavedUsers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).FavedUsers(ctx, req.(*FavedUsersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_CntUserFolders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CntUserFoldersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).CntUserFolders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/CntUserFolders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).CntUserFolders(ctx, req.(*CntUserFoldersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_InDefault_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InDefaultFolderReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).InDefault(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/InDefault",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).InDefault(ctx, req.(*InDefaultFolderReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_MultiDel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MultiDelReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).MultiDel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/MultiDel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).MultiDel(ctx, req.(*MultiDelReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_MultiAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MultiAddReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).MultiAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/MultiAdd",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).MultiAdd(ctx, req.(*MultiAddReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_DelFolder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelFolderReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).DelFolder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/DelFolder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).DelFolder(ctx, req.(*DelFolderReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_UpdateFolder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateFolderReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).UpdateFolder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/UpdateFolder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).UpdateFolder(ctx, req.(*UpdateFolderReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_AddFolder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddFolderReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).AddFolder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/AddFolder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).AddFolder(ctx, req.(*AddFolderReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_Favorites_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FavoritesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).Favorites(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/Favorites",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).Favorites(ctx, req.(*FavoritesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_FavoritesAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FavoritesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).FavoritesAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/FavoritesAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).FavoritesAll(ctx, req.(*FavoritesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_Tlists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TlistsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).Tlists(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/Tlists",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).Tlists(ctx, req.(*TlistsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_RecentFavs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RecentFavsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).RecentFavs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/RecentFavs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).RecentFavs(ctx, req.(*RecentFavsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_RecentResources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RecentResourcesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).RecentResources(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/RecentResources",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).RecentResources(ctx, req.(*RecentResourcesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_IsFavored_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsFavoredReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).IsFavored(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/IsFavored",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).IsFavored(ctx, req.(*IsFavoredReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_IsFavoredByFid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsFavoredByFidReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).IsFavoredByFid(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/IsFavoredByFid",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).IsFavoredByFid(ctx, req.(*IsFavoredByFidReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_IsFavoreds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsFavoredsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).IsFavoreds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/IsFavoreds",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).IsFavoreds(ctx, req.(*IsFavoredsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_AddFav_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddFavReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).AddFav(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/AddFav",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).AddFav(ctx, req.(*AddFavReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_DelFav_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelFavReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).DelFav(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/DelFav",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).DelFav(ctx, req.(*DelFavReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_UserFolders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserFoldersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).UserFolders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/UserFolders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).UserFolders(ctx, req.(*UserFoldersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_UserFolder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserFolderReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).UserFolder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/UserFolder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).UserFolder(ctx, req.(*UserFolderReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_Folders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FoldersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).Folders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/Folders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).Folders(ctx, req.(*FoldersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Favorite_SortFavs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SortFavsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FavoriteServer).SortFavs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/community.service.favorite.Favorite/SortFavs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FavoriteServer).SortFavs(ctx, req.(*SortFavsReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Favorite_serviceDesc = grpc.ServiceDesc{
	ServiceName: "community.service.favorite.Favorite",
	HandlerType: (*FavoriteServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AdminUpdateFolder",
			Handler:    _Favorite_AdminUpdateFolder_Handler,
		},
		{
			MethodName: "FavDelFolders",
			Handler:    _Favorite_FavDelFolders_Handler,
		},
		{
			MethodName: "FavAddFolders",
			Handler:    _Favorite_FavAddFolders_Handler,
		},
		{
			MethodName: "UpFolderName",
			Handler:    _Favorite_UpFolderName_Handler,
		},
		{
			MethodName: "UpFolderAttr",
			Handler:    _Favorite_UpFolderAttr_Handler,
		},
		{
			MethodName: "CleanInvalidFavs",
			Handler:    _Favorite_CleanInvalidFavs_Handler,
		},
		{
			MethodName: "CleanState",
			Handler:    _Favorite_CleanState_Handler,
		},
		{
			MethodName: "CopyFavs",
			Handler:    _Favorite_CopyFavs_Handler,
		},
		{
			MethodName: "MoveFavs",
			Handler:    _Favorite_MoveFavs_Handler,
		},
		{
			MethodName: "SetFolderSort",
			Handler:    _Favorite_SetFolderSort_Handler,
		},
		{
			MethodName: "FavedUsers",
			Handler:    _Favorite_FavedUsers_Handler,
		},
		{
			MethodName: "CntUserFolders",
			Handler:    _Favorite_CntUserFolders_Handler,
		},
		{
			MethodName: "InDefault",
			Handler:    _Favorite_InDefault_Handler,
		},
		{
			MethodName: "MultiDel",
			Handler:    _Favorite_MultiDel_Handler,
		},
		{
			MethodName: "MultiAdd",
			Handler:    _Favorite_MultiAdd_Handler,
		},
		{
			MethodName: "DelFolder",
			Handler:    _Favorite_DelFolder_Handler,
		},
		{
			MethodName: "UpdateFolder",
			Handler:    _Favorite_UpdateFolder_Handler,
		},
		{
			MethodName: "AddFolder",
			Handler:    _Favorite_AddFolder_Handler,
		},
		{
			MethodName: "Favorites",
			Handler:    _Favorite_Favorites_Handler,
		},
		{
			MethodName: "FavoritesAll",
			Handler:    _Favorite_FavoritesAll_Handler,
		},
		{
			MethodName: "Tlists",
			Handler:    _Favorite_Tlists_Handler,
		},
		{
			MethodName: "RecentFavs",
			Handler:    _Favorite_RecentFavs_Handler,
		},
		{
			MethodName: "RecentResources",
			Handler:    _Favorite_RecentResources_Handler,
		},
		{
			MethodName: "IsFavored",
			Handler:    _Favorite_IsFavored_Handler,
		},
		{
			MethodName: "IsFavoredByFid",
			Handler:    _Favorite_IsFavoredByFid_Handler,
		},
		{
			MethodName: "IsFavoreds",
			Handler:    _Favorite_IsFavoreds_Handler,
		},
		{
			MethodName: "AddFav",
			Handler:    _Favorite_AddFav_Handler,
		},
		{
			MethodName: "DelFav",
			Handler:    _Favorite_DelFav_Handler,
		},
		{
			MethodName: "UserFolders",
			Handler:    _Favorite_UserFolders_Handler,
		},
		{
			MethodName: "UserFolder",
			Handler:    _Favorite_UserFolder_Handler,
		},
		{
			MethodName: "Folders",
			Handler:    _Favorite_Folders_Handler,
		},
		{
			MethodName: "SortFavs",
			Handler:    _Favorite_SortFavs_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/main/favorite/api/api.proto",
}

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

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

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

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

func (m *AddFavReq) 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 *AddFavReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Tp != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Tp))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Oid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Oid))
	}
	if m.Otype != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Otype))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *DelFavReq) 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 *DelFavReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Tp != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Tp))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Oid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Oid))
	}
	if m.Otype != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Otype))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *FavoritesReq) 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 *FavoritesReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Tp != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Tp))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Uid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Uid))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Pn != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Pn))
	}
	if m.Ps != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ps))
	}
	if m.Tid != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Tid))
	}
	if m.Tv != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Tv))
	}
	if len(m.Keyword) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Keyword)))
		i += copy(dAtA[i:], m.Keyword)
	}
	if len(m.Order) > 0 {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Order)))
		i += copy(dAtA[i:], m.Order)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

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

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

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

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

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

func (m *IsFavoredsReq) 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 *IsFavoredsReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Oids) > 0 {
		dAtA6 := make([]byte, len(m.Oids)*10)
		var j5 int
		for _, num1 := range m.Oids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(j5))
		i += copy(dAtA[i:], dAtA6[:j5])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *UserFoldersReq) 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 *UserFoldersReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Vmid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Vmid))
	}
	if m.Oid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Oid))
	}
	if m.AllCount {
		dAtA[i] = 0x30
		i++
		if m.AllCount {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Otype != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Otype))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *UserFolderReq) 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 *UserFolderReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Vmid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Vmid))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.AllCount {
		dAtA[i] = 0x30
		i++
		if m.AllCount {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AddFolderReq) 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 *AddFolderReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Description) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Description)))
		i += copy(dAtA[i:], m.Description)
	}
	if len(m.Cover) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cover)))
		i += copy(dAtA[i:], m.Cover)
	}
	if m.Public != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Public))
	}
	if len(m.Cookie) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cookie)))
		i += copy(dAtA[i:], m.Cookie)
	}
	if len(m.AccessKey) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.AccessKey)))
		i += copy(dAtA[i:], m.AccessKey)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *UpdateFolderReq) 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 *UpdateFolderReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Description) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Description)))
		i += copy(dAtA[i:], m.Description)
	}
	if len(m.Cover) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cover)))
		i += copy(dAtA[i:], m.Cover)
	}
	if m.Public != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Public))
	}
	if len(m.Cookie) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cookie)))
		i += copy(dAtA[i:], m.Cookie)
	}
	if len(m.AccessKey) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.AccessKey)))
		i += copy(dAtA[i:], m.AccessKey)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AdminUpdateFolderReq) 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 *AdminUpdateFolderReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Description) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Description)))
		i += copy(dAtA[i:], m.Description)
	}
	if len(m.Cover) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cover)))
		i += copy(dAtA[i:], m.Cover)
	}
	if m.State != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.State))
	}
	if m.Attr != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Attr))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *MultiAddReq) 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 *MultiAddReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Oids) > 0 {
		dAtA9 := make([]byte, len(m.Oids)*10)
		var j8 int
		for _, num1 := range m.Oids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j8))
		i += copy(dAtA[i:], dAtA9[:j8])
	}
	if m.Fid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *MultiDelReq) 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 *MultiDelReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Oids) > 0 {
		dAtA11 := make([]byte, len(m.Oids)*10)
		var j10 int
		for _, num1 := range m.Oids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j10))
		i += copy(dAtA[i:], dAtA11[:j10])
	}
	if m.Fid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

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

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

func (m *FavedUsersReply) 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 *FavedUsersReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Page != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Page.Size()))
		n12, err := m.Page.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if len(m.User) > 0 {
		for _, msg := range m.User {
			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 *FavedUsersReq) 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 *FavedUsersReq) 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))
	}
	if m.Oid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Oid))
	}
	if m.Pn != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Pn))
	}
	if m.Ps != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ps))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *SetFolderSortReq) 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 *SetFolderSortReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Fids) > 0 {
		dAtA14 := make([]byte, len(m.Fids)*10)
		var j13 int
		for _, num1 := range m.Fids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(j13))
		i += copy(dAtA[i:], dAtA14[:j13])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *FoldersReq) 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 *FoldersReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		for _, msg := range m.Ids {
			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.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		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 *FolderID) 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 *FolderID) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Fid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		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 *MoveFavsReq) 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 *MoveFavsReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.OldFid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.OldFid))
	}
	if m.NewFid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.NewFid))
	}
	if len(m.Oids) > 0 {
		dAtA16 := make([]byte, len(m.Oids)*10)
		var j15 int
		for _, num1 := range m.Oids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j15++
			}
			dAtA16[j15] = uint8(num)
			j15++
		}
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j15))
		i += copy(dAtA[i:], dAtA16[:j15])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CopyFavsReq) 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 *CopyFavsReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.OldMid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.OldMid))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.OldFid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.OldFid))
	}
	if m.NewFid != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.NewFid))
	}
	if len(m.Oids) > 0 {
		dAtA18 := make([]byte, len(m.Oids)*10)
		var j17 int
		for _, num1 := range m.Oids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j17++
			}
			dAtA18[j17] = uint8(num)
			j17++
		}
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(j17))
		i += copy(dAtA[i:], dAtA18[:j17])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

func (m *FavAddFoldersReq) 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 *FavAddFoldersReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Oid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Oid))
	}
	if m.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if len(m.Fids) > 0 {
		dAtA20 := make([]byte, len(m.Fids)*10)
		var j19 int
		for _, num1 := range m.Fids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j19++
			}
			dAtA20[j19] = uint8(num)
			j19++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j19))
		i += copy(dAtA[i:], dAtA20[:j19])
	}
	if m.Mid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Otype != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Otype))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *FavDelFoldersReq) 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 *FavDelFoldersReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Oid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Oid))
	}
	if m.Typ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if len(m.Fids) > 0 {
		dAtA22 := make([]byte, len(m.Fids)*10)
		var j21 int
		for _, num1 := range m.Fids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA22[j21] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j21++
			}
			dAtA22[j21] = uint8(num)
			j21++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j21))
		i += copy(dAtA[i:], dAtA22[:j21])
	}
	if m.Mid != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Otype != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Otype))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *SortFavsReq) 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 *SortFavsReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Sorts) > 0 {
		for _, msg := range m.Sorts {
			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.Mid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Typ != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *UpFolderNameReq) 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 *UpFolderNameReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Typ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Typ))
	}
	if m.Fid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Fid))
	}
	if m.Mid != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Cookie) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cookie)))
		i += copy(dAtA[i:], m.Cookie)
	}
	if len(m.AccessKey) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.AccessKey)))
		i += copy(dAtA[i:], m.AccessKey)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

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

func (m *ModelFavorite) Size() (n int) {
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovApi(uint64(m.Id))
	}
	if m.Oid != 0 {
		n += 1 + sovApi(uint64(m.Oid))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Fid != 0 {
		n += 1 + sovApi(uint64(m.Fid))
	}
	if m.Type != 0 {
		n += 1 + sovApi(uint64(m.Type))
	}
	if m.State != 0 {
		n += 1 + sovApi(uint64(m.State))
	}
	if m.Ctime != 0 {
		n += 1 + sovApi(uint64(m.Ctime))
	}
	if m.Mtime != 0 {
		n += 1 + sovApi(uint64(m.Mtime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

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

func (m *FavoritesReq) Size() (n int) {
	var l int
	_ = l
	if m.Tp != 0 {
		n += 1 + sovApi(uint64(m.Tp))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Uid != 0 {
		n += 1 + sovApi(uint64(m.Uid))
	}
	if m.Fid != 0 {
		n += 1 + sovApi(uint64(m.Fid))
	}
	if m.Pn != 0 {
		n += 1 + sovApi(uint64(m.Pn))
	}
	if m.Ps != 0 {
		n += 1 + sovApi(uint64(m.Ps))
	}
	if m.Tid != 0 {
		n += 1 + sovApi(uint64(m.Tid))
	}
	if m.Tv != 0 {
		n += 1 + sovApi(uint64(m.Tv))
	}
	l = len(m.Keyword)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Order)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

func (m *UserFoldersReq) Size() (n int) {
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovApi(uint64(m.Typ))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Vmid != 0 {
		n += 1 + sovApi(uint64(m.Vmid))
	}
	if m.Oid != 0 {
		n += 1 + sovApi(uint64(m.Oid))
	}
	if m.AllCount {
		n += 2
	}
	if m.Otype != 0 {
		n += 1 + sovApi(uint64(m.Otype))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *UserFolderReq) Size() (n int) {
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovApi(uint64(m.Typ))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Vmid != 0 {
		n += 1 + sovApi(uint64(m.Vmid))
	}
	if m.Fid != 0 {
		n += 1 + sovApi(uint64(m.Fid))
	}
	if m.AllCount {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddFolderReq) Size() (n int) {
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovApi(uint64(m.Typ))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Cover)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Public != 0 {
		n += 1 + sovApi(uint64(m.Public))
	}
	l = len(m.Cookie)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.AccessKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *UpdateFolderReq) Size() (n int) {
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovApi(uint64(m.Typ))
	}
	if m.Fid != 0 {
		n += 1 + sovApi(uint64(m.Fid))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Cover)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Public != 0 {
		n += 1 + sovApi(uint64(m.Public))
	}
	l = len(m.Cookie)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.AccessKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AdminUpdateFolderReq) Size() (n int) {
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovApi(uint64(m.Typ))
	}
	if m.Fid != 0 {
		n += 1 + sovApi(uint64(m.Fid))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Cover)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovApi(uint64(m.State))
	}
	if m.Attr != 0 {
		n += 1 + sovApi(uint64(m.Attr))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

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

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

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

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

func (m *FavedUsersReq) Size() (n int) {
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovApi(uint64(m.Type))
	}
	if m.Oid != 0 {
		n += 1 + sovApi(uint64(m.Oid))
	}
	if m.Pn != 0 {
		n += 1 + sovApi(uint64(m.Pn))
	}
	if m.Ps != 0 {
		n += 1 + sovApi(uint64(m.Ps))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *UpFolderNameReq) Size() (n int) {
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovApi(uint64(m.Typ))
	}
	if m.Fid != 0 {
		n += 1 + sovApi(uint64(m.Fid))
	}
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Cookie)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.AccessKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FavoritesReply) 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: FavoritesReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FavoritesReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Res == nil {
				m.Res = &ModelFavorites{}
			}
			if err := m.Res.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 *FavoritesReq) 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: FavoritesReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FavoritesReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType)
			}
			m.Tp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tp |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
			}
			m.Uid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pn", wireType)
			}
			m.Pn = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Pn |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ps", wireType)
			}
			m.Ps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ps |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tid", wireType)
			}
			m.Tid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tid |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tv", wireType)
			}
			m.Tv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Tv |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keyword", 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.Keyword = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Order", 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.Order = 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 *TlistsReply) 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: TlistsReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TlistsReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Res = append(m.Res, &ModelPartition{})
			if err := m.Res[len(m.Res)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UserFolderReply) 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: UserFolderReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserFolderReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Res == nil {
				m.Res = &model.Folder{}
			}
			if err := m.Res.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 *UserFolderReq) 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: UserFolderReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UserFolderReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vmid", wireType)
			}
			m.Vmid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Vmid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllCount", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllCount = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AddFolderReq) 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: AddFolderReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddFolderReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cover", 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.Cover = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Public", wireType)
			}
			m.Public = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Public |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cookie", 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.Cookie = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", 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.AccessKey = 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 *AddFolderReply) 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: AddFolderReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddFolderReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (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 *UpdateFolderReq) 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: UpdateFolderReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateFolderReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cover", 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.Cover = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Public", wireType)
			}
			m.Public = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Public |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cookie", 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.Cookie = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", 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.AccessKey = 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 *AdminUpdateFolderReq) 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: AdminUpdateFolderReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AdminUpdateFolderReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cover", 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.Cover = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attr", wireType)
			}
			m.Attr = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Attr |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelFolderReq) 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: DelFolderReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelFolderReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (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 *MultiAddReq) 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: MultiAddReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultiAddReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 == 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.Oids = append(m.Oids, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Oids = append(m.Oids, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Oids", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (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 *MultiDelReq) 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: MultiDelReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MultiDelReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 == 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.Oids = append(m.Oids, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Oids = append(m.Oids, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Oids", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (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 *InDefaultFolderReq) 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: InDefaultFolderReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InDefaultFolderReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Oid", wireType)
			}
			m.Oid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Oid |= (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 *InDefaultFolderReply) 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: InDefaultFolderReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InDefaultFolderReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsIn", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsIn = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FoldersReq) 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: FoldersReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FoldersReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", 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.Ids = append(m.Ids, &FolderID{})
			if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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
				}
			}
		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 *FolderID) 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: FolderID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FolderID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (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
				}
			}
		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 *MoveFavsReq) 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: MoveFavsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MoveFavsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldFid", wireType)
			}
			m.OldFid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OldFid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewFid", wireType)
			}
			m.NewFid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NewFid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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.Oids = append(m.Oids, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Oids = append(m.Oids, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Oids", 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 *CopyFavsReq) 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: CopyFavsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CopyFavsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldMid", wireType)
			}
			m.OldMid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OldMid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldFid", wireType)
			}
			m.OldFid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OldFid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewFid", wireType)
			}
			m.NewFid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NewFid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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.Oids = append(m.Oids, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Oids = append(m.Oids, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Oids", 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 *CleanStateReq) 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: CleanStateReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CleanStateReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (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 *CleanStateReply) 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: CleanStateReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CleanStateReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CleanState", wireType)
			}
			m.CleanState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CleanState |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SortFav) 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: SortFav: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SortFav: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pre", 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.Pre == nil {
				m.Pre = &model.Resource{}
			}
			if err := m.Pre.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insert", 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.Insert == nil {
				m.Insert = &model.Resource{}
			}
			if err := m.Insert.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 *UpFolderNameReq) 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: UpFolderNameReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpFolderNameReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 Name", 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.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cookie", 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.Cookie = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", 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.AccessKey = 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 *UpFolderAttrReq) 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: UpFolderAttrReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpFolderAttrReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)
			}
			m.Fid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Public", wireType)
			}
			m.Public = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Public |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func 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/favorite/api/api.proto", fileDescriptor_api_ba1420d9f4484993)
}

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