// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v1/Remind.proto

package v1

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

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 RemindOperateReq struct {
	// 活动 id
	Aid int64 `protobuf:"varint,1,opt,name=aid,proto3" json:"aid"`
	// 0.取消 1.预约
	Action int64 `protobuf:"varint,2,opt,name=action,proto3" json:"action"`
}

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

var xxx_messageInfo_RemindOperateReq proto.InternalMessageInfo

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

func (m *RemindOperateReq) GetAction() int64 {
	if m != nil {
		return m.Action
	}
	return 0
}

type RemindOperateResp struct {
	// code
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	// msg
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Data *RemindOperateResp_Data `protobuf:"bytes,3,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_RemindOperateResp proto.InternalMessageInfo

func (m *RemindOperateResp) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *RemindOperateResp) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *RemindOperateResp) GetData() *RemindOperateResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type RemindOperateResp_Data struct {
}

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

var xxx_messageInfo_RemindOperateResp_Data proto.InternalMessageInfo

type RemindQueryReq struct {
	// 活动 id
	Aid int64 `protobuf:"varint,1,opt,name=aid,proto3" json:"aid"`
}

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

var xxx_messageInfo_RemindQueryReq proto.InternalMessageInfo

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

type RemindQueryResp struct {
	// code
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	// msg
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Data *RemindQueryResp_Data `protobuf:"bytes,3,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_RemindQueryResp proto.InternalMessageInfo

func (m *RemindQueryResp) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *RemindQueryResp) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *RemindQueryResp) GetData() *RemindQueryResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type RemindQueryResp_Data struct {
	// 活动 ID
	Aid int64 `protobuf:"varint,1,opt,name=aid,proto3" json:"aid"`
	// 1.已经预约 2.没有预约
	Status int64 `protobuf:"varint,2,opt,name=status,proto3" json:"status"`
}

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

var xxx_messageInfo_RemindQueryResp_Data proto.InternalMessageInfo

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

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

type RemindSubmitReq struct {
	// 事件类型
	Type int64 `protobuf:"varint,1,opt,name=type,proto3" json:"type"`
	// 事件 id (多个用逗号拼接)
	EventId string `protobuf:"bytes,2,opt,name=event_id,json=eventId,proto3" json:"event_id"`
	// 提交来源
	Source int64 `protobuf:"varint,3,opt,name=source,proto3" json:"source"`
	// 1.预约 2.取消预约
	Action int64 `protobuf:"varint,4,opt,name=action,proto3" json:"action"`
}

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

var xxx_messageInfo_RemindSubmitReq proto.InternalMessageInfo

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

func (m *RemindSubmitReq) GetEventId() string {
	if m != nil {
		return m.EventId
	}
	return ""
}

func (m *RemindSubmitReq) GetSource() int64 {
	if m != nil {
		return m.Source
	}
	return 0
}

func (m *RemindSubmitReq) GetAction() int64 {
	if m != nil {
		return m.Action
	}
	return 0
}

type RemindSubmitResp struct {
	// code
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	// msg　(预约成功，已过期，未开始)
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Data *RemindSubmitResp_Data `protobuf:"bytes,3,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_RemindSubmitResp proto.InternalMessageInfo

func (m *RemindSubmitResp) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *RemindSubmitResp) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *RemindSubmitResp) GetData() *RemindSubmitResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type RemindSubmitResp_Data struct {
}

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

var xxx_messageInfo_RemindSubmitResp_Data proto.InternalMessageInfo

type RemindGetReq struct {
	// 事件类型
	Type int64 `protobuf:"varint,1,opt,name=type,proto3" json:"type"`
	// 事件 id
	EventId string `protobuf:"bytes,2,opt,name=event_id,json=eventId,proto3" json:"event_id"`
}

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

var xxx_messageInfo_RemindGetReq proto.InternalMessageInfo

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

func (m *RemindGetReq) GetEventId() string {
	if m != nil {
		return m.EventId
	}
	return ""
}

type RemindGetResp struct {
	// code
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	// msg
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Data *RemindGetResp_Data `protobuf:"bytes,3,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_RemindGetResp proto.InternalMessageInfo

func (m *RemindGetResp) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *RemindGetResp) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

func (m *RemindGetResp) GetData() *RemindGetResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type RemindGetResp_List struct {
	// 事件类型
	Type int64 `protobuf:"varint,1,opt,name=type,proto3" json:"type"`
	// 活动 ID
	EventId int64 `protobuf:"varint,2,opt,name=event_id,json=eventId,proto3" json:"event_id"`
	// 1.已经预约 2.没有预约
	Status int64 `protobuf:"varint,3,opt,name=status,proto3" json:"status"`
	// 预约的时间
	Date string `protobuf:"bytes,4,opt,name=date,proto3" json:"date"`
}

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

var xxx_messageInfo_RemindGetResp_List proto.InternalMessageInfo

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

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

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

func (m *RemindGetResp_List) GetDate() string {
	if m != nil {
		return m.Date
	}
	return ""
}

type RemindGetResp_Data struct {
	//
	List []*RemindGetResp_List `protobuf:"bytes,1,rep,name=list" json:"list"`
}

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

var xxx_messageInfo_RemindGetResp_Data proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*RemindOperateReq)(nil), "userext.v1.RemindOperateReq")
	proto.RegisterType((*RemindOperateResp)(nil), "userext.v1.RemindOperateResp")
	proto.RegisterType((*RemindOperateResp_Data)(nil), "userext.v1.RemindOperateResp.Data")
	proto.RegisterType((*RemindQueryReq)(nil), "userext.v1.RemindQueryReq")
	proto.RegisterType((*RemindQueryResp)(nil), "userext.v1.RemindQueryResp")
	proto.RegisterType((*RemindQueryResp_Data)(nil), "userext.v1.RemindQueryResp.Data")
	proto.RegisterType((*RemindSubmitReq)(nil), "userext.v1.RemindSubmitReq")
	proto.RegisterType((*RemindSubmitResp)(nil), "userext.v1.RemindSubmitResp")
	proto.RegisterType((*RemindSubmitResp_Data)(nil), "userext.v1.RemindSubmitResp.Data")
	proto.RegisterType((*RemindGetReq)(nil), "userext.v1.RemindGetReq")
	proto.RegisterType((*RemindGetResp)(nil), "userext.v1.RemindGetResp")
	proto.RegisterType((*RemindGetResp_List)(nil), "userext.v1.RemindGetResp.List")
	proto.RegisterType((*RemindGetResp_Data)(nil), "userext.v1.RemindGetResp.Data")
}
func (m *RemindOperateReq) 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 *RemindOperateReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Aid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Aid))
	}
	if m.Action != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Action))
	}
	return i, nil
}

func (m *RemindOperateResp) 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 *RemindOperateResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRemind(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Data.Size()))
		n1, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

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

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

func (m *RemindQueryResp) 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 *RemindQueryResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRemind(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Data.Size()))
		n2, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}

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

func (m *RemindSubmitReq) 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 *RemindSubmitReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Type))
	}
	if len(m.EventId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRemind(dAtA, i, uint64(len(m.EventId)))
		i += copy(dAtA[i:], m.EventId)
	}
	if m.Source != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Source))
	}
	if m.Action != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Action))
	}
	return i, nil
}

func (m *RemindSubmitResp) 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 *RemindSubmitResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRemind(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Data.Size()))
		n3, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

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

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

func (m *RemindGetResp) 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 *RemindGetResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRemind(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Data.Size()))
		n4, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

func (m *RemindGetResp_List) 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 *RemindGetResp_List) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Type))
	}
	if m.EventId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.EventId))
	}
	if m.Status != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintRemind(dAtA, i, uint64(m.Status))
	}
	if len(m.Date) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintRemind(dAtA, i, uint64(len(m.Date)))
		i += copy(dAtA[i:], m.Date)
	}
	return i, nil
}

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

func encodeVarintRemind(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 *RemindOperateReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Aid != 0 {
		n += 1 + sovRemind(uint64(m.Aid))
	}
	if m.Action != 0 {
		n += 1 + sovRemind(uint64(m.Action))
	}
	return n
}

func (m *RemindOperateResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovRemind(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovRemind(uint64(l))
	}
	return n
}

func (m *RemindOperateResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemindQueryReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Aid != 0 {
		n += 1 + sovRemind(uint64(m.Aid))
	}
	return n
}

func (m *RemindQueryResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovRemind(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovRemind(uint64(l))
	}
	return n
}

func (m *RemindQueryResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Aid != 0 {
		n += 1 + sovRemind(uint64(m.Aid))
	}
	if m.Status != 0 {
		n += 1 + sovRemind(uint64(m.Status))
	}
	return n
}

func (m *RemindSubmitReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovRemind(uint64(m.Type))
	}
	l = len(m.EventId)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	if m.Source != 0 {
		n += 1 + sovRemind(uint64(m.Source))
	}
	if m.Action != 0 {
		n += 1 + sovRemind(uint64(m.Action))
	}
	return n
}

func (m *RemindSubmitResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovRemind(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovRemind(uint64(l))
	}
	return n
}

func (m *RemindSubmitResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RemindGetReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovRemind(uint64(m.Type))
	}
	l = len(m.EventId)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	return n
}

func (m *RemindGetResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovRemind(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovRemind(uint64(l))
	}
	return n
}

func (m *RemindGetResp_List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovRemind(uint64(m.Type))
	}
	if m.EventId != 0 {
		n += 1 + sovRemind(uint64(m.EventId))
	}
	if m.Status != 0 {
		n += 1 + sovRemind(uint64(m.Status))
	}
	l = len(m.Date)
	if l > 0 {
		n += 1 + l + sovRemind(uint64(l))
	}
	return n
}

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

func sovRemind(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRemind(x uint64) (n int) {
	return sovRemind(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RemindOperateReq) 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 ErrIntOverflowRemind
			}
			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: RemindOperateReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindOperateReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Aid", wireType)
			}
			m.Aid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Aid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindOperateResp) 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 ErrIntOverflowRemind
			}
			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: RemindOperateResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindOperateResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRemind
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &RemindOperateResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindQueryResp) 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 ErrIntOverflowRemind
			}
			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: RemindQueryResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindQueryResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRemind
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &RemindQueryResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindSubmitReq) 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 ErrIntOverflowRemind
			}
			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: RemindSubmitReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindSubmitReq: 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 ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			m.Source = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindSubmitResp) 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 ErrIntOverflowRemind
			}
			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: RemindSubmitResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindSubmitResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRemind
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &RemindSubmitResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindGetReq) 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 ErrIntOverflowRemind
			}
			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: RemindGetReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindGetReq: 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 ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindGetResp) 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 ErrIntOverflowRemind
			}
			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: RemindGetResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemindGetResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRemind
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &RemindGetResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemindGetResp_List) 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 ErrIntOverflowRemind
			}
			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: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: 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 ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventId", wireType)
			}
			m.EventId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Date", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRemind
				}
				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 ErrInvalidLengthRemind
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Date = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRemind(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRemind
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRemind(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, ErrIntOverflowRemind
			}
			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, ErrIntOverflowRemind
				}
				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, ErrIntOverflowRemind
				}
				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, ErrInvalidLengthRemind
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowRemind
					}
					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 := skipRemind(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 (
	ErrInvalidLengthRemind = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRemind   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("v1/Remind.proto", fileDescriptor_Remind_4b3538f1a70e3208) }

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