bilibili-go-common/app/service/live/fans_medal/api/liverpc/v1/Medal.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v1/Medal.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 MedalCreateReq struct {
	//
	Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
	//
	Source int64 `protobuf:"varint,2,opt,name=source,proto3" json:"source"`
}

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

var xxx_messageInfo_MedalCreateReq proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_MedalCreateResp proto.InternalMessageInfo

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

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

func (m *MedalCreateResp) GetData() *MedalCreateResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type MedalCreateResp_Data struct {
	// 勋章ID
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id"`
	// up主uid
	Uid int64 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid"`
	// 勋章名称
	MedalName string `protobuf:"bytes,3,opt,name=medal_name,json=medalName,proto3" json:"medal_name"`
	// 直播开通状态 0 冻结 1 可用
	LiveStatus int64 `protobuf:"varint,4,opt,name=live_status,json=liveStatus,proto3" json:"live_status"`
	// 主站开通状态 0 冻结 1 可用
	MasterStatus int64 `protobuf:"varint,5,opt,name=master_status,json=masterStatus,proto3" json:"master_status"`
	// 勋章审核状态 -1已拒绝 0未申请 1已申请 2已开通
	Status int64 `protobuf:"varint,6,opt,name=status,proto3" json:"status"`
	// 审核不通过通过的理由
	Reason string `protobuf:"bytes,7,opt,name=reason,proto3" json:"reason"`
	// 申请来源
	ApplySource int64 `protobuf:"varint,8,opt,name=apply_source,json=applySource,proto3" json:"apply_source"`
	// 最后一次修改勋章名称的时间戳
	LastRenameTime int64 `protobuf:"varint,9,opt,name=last_rename_time,json=lastRenameTime,proto3" json:"last_rename_time"`
	// 改名状态
	RenameStatus int64 `protobuf:"varint,10,opt,name=rename_status,json=renameStatus,proto3" json:"rename_status"`
	// 充电超过该数值可获得勋章
	ChargeNum int64 `protobuf:"varint,11,opt,name=charge_num,json=chargeNum,proto3" json:"charge_num"`
	// 投币超过该数值可获得勋章
	CoinNum int64 `protobuf:"varint,12,opt,name=coin_num,json=coinNum,proto3" json:"coin_num"`
	// 没有勋章时为 true
	IsNull bool `protobuf:"varint,13,opt,name=is_null,json=isNull,proto3" json:"is_null"`
}

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

var xxx_messageInfo_MedalCreateResp_Data proto.InternalMessageInfo

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

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

func (m *MedalCreateResp_Data) GetMedalName() string {
	if m != nil {
		return m.MedalName
	}
	return ""
}

func (m *MedalCreateResp_Data) GetLiveStatus() int64 {
	if m != nil {
		return m.LiveStatus
	}
	return 0
}

func (m *MedalCreateResp_Data) GetMasterStatus() int64 {
	if m != nil {
		return m.MasterStatus
	}
	return 0
}

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

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

func (m *MedalCreateResp_Data) GetApplySource() int64 {
	if m != nil {
		return m.ApplySource
	}
	return 0
}

func (m *MedalCreateResp_Data) GetLastRenameTime() int64 {
	if m != nil {
		return m.LastRenameTime
	}
	return 0
}

func (m *MedalCreateResp_Data) GetRenameStatus() int64 {
	if m != nil {
		return m.RenameStatus
	}
	return 0
}

func (m *MedalCreateResp_Data) GetChargeNum() int64 {
	if m != nil {
		return m.ChargeNum
	}
	return 0
}

func (m *MedalCreateResp_Data) GetCoinNum() int64 {
	if m != nil {
		return m.CoinNum
	}
	return 0
}

func (m *MedalCreateResp_Data) GetIsNull() bool {
	if m != nil {
		return m.IsNull
	}
	return false
}

type MedalQueryReq struct {
	//
	Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
	//
	Source int64 `protobuf:"varint,2,opt,name=source,proto3" json:"source"`
}

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

var xxx_messageInfo_MedalQueryReq proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_MedalQueryResp proto.InternalMessageInfo

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

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

func (m *MedalQueryResp) GetData() *MedalQueryResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type MedalQueryResp_Data struct {
	// 勋章ID
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id"`
	// up主uid
	Uid int64 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid"`
	// 勋章名称
	MedalName string `protobuf:"bytes,3,opt,name=medal_name,json=medalName,proto3" json:"medal_name"`
	// 直播开通状态 0 冻结 1 可用
	LiveStatus int64 `protobuf:"varint,4,opt,name=live_status,json=liveStatus,proto3" json:"live_status"`
	// 主站开通状态 0 冻结 1 可用
	MasterStatus int64 `protobuf:"varint,5,opt,name=master_status,json=masterStatus,proto3" json:"master_status"`
	// 勋章审核状态 -1已拒绝 0未申请 1已申请 2已开通
	Status int64 `protobuf:"varint,6,opt,name=status,proto3" json:"status"`
	// 审核不通过通过的理由
	Reason string `protobuf:"bytes,7,opt,name=reason,proto3" json:"reason"`
	// 申请来源
	ApplySource int64 `protobuf:"varint,8,opt,name=apply_source,json=applySource,proto3" json:"apply_source"`
	// 最后一次修改勋章名称的时间戳
	LastRenameTime int64 `protobuf:"varint,9,opt,name=last_rename_time,json=lastRenameTime,proto3" json:"last_rename_time"`
	// 改名状态
	RenameStatus int64 `protobuf:"varint,10,opt,name=rename_status,json=renameStatus,proto3" json:"rename_status"`
	// 充电超过该数值可获得勋章
	ChargeNum int64 `protobuf:"varint,11,opt,name=charge_num,json=chargeNum,proto3" json:"charge_num"`
	// 投币超过该数值可获得勋章
	CoinNum int64 `protobuf:"varint,12,opt,name=coin_num,json=coinNum,proto3" json:"coin_num"`
	// 没有勋章时为 true
	IsNull bool `protobuf:"varint,13,opt,name=is_null,json=isNull,proto3" json:"is_null"`
}

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

var xxx_messageInfo_MedalQueryResp_Data proto.InternalMessageInfo

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

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

func (m *MedalQueryResp_Data) GetMedalName() string {
	if m != nil {
		return m.MedalName
	}
	return ""
}

func (m *MedalQueryResp_Data) GetLiveStatus() int64 {
	if m != nil {
		return m.LiveStatus
	}
	return 0
}

func (m *MedalQueryResp_Data) GetMasterStatus() int64 {
	if m != nil {
		return m.MasterStatus
	}
	return 0
}

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

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

func (m *MedalQueryResp_Data) GetApplySource() int64 {
	if m != nil {
		return m.ApplySource
	}
	return 0
}

func (m *MedalQueryResp_Data) GetLastRenameTime() int64 {
	if m != nil {
		return m.LastRenameTime
	}
	return 0
}

func (m *MedalQueryResp_Data) GetRenameStatus() int64 {
	if m != nil {
		return m.RenameStatus
	}
	return 0
}

func (m *MedalQueryResp_Data) GetChargeNum() int64 {
	if m != nil {
		return m.ChargeNum
	}
	return 0
}

func (m *MedalQueryResp_Data) GetCoinNum() int64 {
	if m != nil {
		return m.CoinNum
	}
	return 0
}

func (m *MedalQueryResp_Data) GetIsNull() bool {
	if m != nil {
		return m.IsNull
	}
	return false
}

type MedalQueryIdReq struct {
	//
	MedalId int64 `protobuf:"varint,1,opt,name=medal_id,json=medalId,proto3" json:"medal_id"`
}

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

var xxx_messageInfo_MedalQueryIdReq proto.InternalMessageInfo

func (m *MedalQueryIdReq) GetMedalId() int64 {
	if m != nil {
		return m.MedalId
	}
	return 0
}

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

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

var xxx_messageInfo_MedalQueryIdResp proto.InternalMessageInfo

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

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

func (m *MedalQueryIdResp) GetData() *MedalQueryIdResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type MedalQueryIdResp_Data struct {
	//
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id"`
	//
	Uid int64 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid"`
	//
	MedalName string `protobuf:"bytes,3,opt,name=medal_name,json=medalName,proto3" json:"medal_name"`
	//
	LiveStatus int64 `protobuf:"varint,4,opt,name=live_status,json=liveStatus,proto3" json:"live_status"`
	//
	MasterStatus int64 `protobuf:"varint,5,opt,name=master_status,json=masterStatus,proto3" json:"master_status"`
	//
	Status int64 `protobuf:"varint,6,opt,name=status,proto3" json:"status"`
	//
	Reason int64 `protobuf:"varint,7,opt,name=reason,proto3" json:"reason"`
	//
	LastRenameTime int64 `protobuf:"varint,8,opt,name=last_rename_time,json=lastRenameTime,proto3" json:"last_rename_time"`
	//
	IsNull bool `protobuf:"varint,9,opt,name=is_null,json=isNull,proto3" json:"is_null"`
}

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

var xxx_messageInfo_MedalQueryIdResp_Data proto.InternalMessageInfo

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

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

func (m *MedalQueryIdResp_Data) GetMedalName() string {
	if m != nil {
		return m.MedalName
	}
	return ""
}

func (m *MedalQueryIdResp_Data) GetLiveStatus() int64 {
	if m != nil {
		return m.LiveStatus
	}
	return 0
}

func (m *MedalQueryIdResp_Data) GetMasterStatus() int64 {
	if m != nil {
		return m.MasterStatus
	}
	return 0
}

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

func (m *MedalQueryIdResp_Data) GetReason() int64 {
	if m != nil {
		return m.Reason
	}
	return 0
}

func (m *MedalQueryIdResp_Data) GetLastRenameTime() int64 {
	if m != nil {
		return m.LastRenameTime
	}
	return 0
}

func (m *MedalQueryIdResp_Data) GetIsNull() bool {
	if m != nil {
		return m.IsNull
	}
	return false
}

func init() {
	proto.RegisterType((*MedalCreateReq)(nil), "fans_medal.v1.MedalCreateReq")
	proto.RegisterType((*MedalCreateResp)(nil), "fans_medal.v1.MedalCreateResp")
	proto.RegisterType((*MedalCreateResp_Data)(nil), "fans_medal.v1.MedalCreateResp.Data")
	proto.RegisterType((*MedalQueryReq)(nil), "fans_medal.v1.MedalQueryReq")
	proto.RegisterType((*MedalQueryResp)(nil), "fans_medal.v1.MedalQueryResp")
	proto.RegisterType((*MedalQueryResp_Data)(nil), "fans_medal.v1.MedalQueryResp.Data")
	proto.RegisterType((*MedalQueryIdReq)(nil), "fans_medal.v1.MedalQueryIdReq")
	proto.RegisterType((*MedalQueryIdResp)(nil), "fans_medal.v1.MedalQueryIdResp")
	proto.RegisterType((*MedalQueryIdResp_Data)(nil), "fans_medal.v1.MedalQueryIdResp.Data")
}
func (m *MedalCreateReq) 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 *MedalCreateReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Uid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Uid))
	}
	if m.Source != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Source))
	}
	return i, nil
}

func (m *MedalCreateResp) 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 *MedalCreateResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMedal(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 *MedalCreateResp_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 *MedalCreateResp_Data) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Id))
	}
	if m.Uid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Uid))
	}
	if len(m.MedalName) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.MedalName)))
		i += copy(dAtA[i:], m.MedalName)
	}
	if m.LiveStatus != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.LiveStatus))
	}
	if m.MasterStatus != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.MasterStatus))
	}
	if m.Status != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Status))
	}
	if len(m.Reason) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.Reason)))
		i += copy(dAtA[i:], m.Reason)
	}
	if m.ApplySource != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.ApplySource))
	}
	if m.LastRenameTime != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.LastRenameTime))
	}
	if m.RenameStatus != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.RenameStatus))
	}
	if m.ChargeNum != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.ChargeNum))
	}
	if m.CoinNum != 0 {
		dAtA[i] = 0x60
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.CoinNum))
	}
	if m.IsNull {
		dAtA[i] = 0x68
		i++
		if m.IsNull {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

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

func (m *MedalQueryResp) 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 *MedalQueryResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMedal(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 *MedalQueryResp_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 *MedalQueryResp_Data) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Id))
	}
	if m.Uid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Uid))
	}
	if len(m.MedalName) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.MedalName)))
		i += copy(dAtA[i:], m.MedalName)
	}
	if m.LiveStatus != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.LiveStatus))
	}
	if m.MasterStatus != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.MasterStatus))
	}
	if m.Status != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Status))
	}
	if len(m.Reason) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.Reason)))
		i += copy(dAtA[i:], m.Reason)
	}
	if m.ApplySource != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.ApplySource))
	}
	if m.LastRenameTime != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.LastRenameTime))
	}
	if m.RenameStatus != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.RenameStatus))
	}
	if m.ChargeNum != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.ChargeNum))
	}
	if m.CoinNum != 0 {
		dAtA[i] = 0x60
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.CoinNum))
	}
	if m.IsNull {
		dAtA[i] = 0x68
		i++
		if m.IsNull {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

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

func (m *MedalQueryIdResp) 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 *MedalQueryIdResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if m.Data != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMedal(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 *MedalQueryIdResp_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 *MedalQueryIdResp_Data) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Id))
	}
	if m.Uid != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Uid))
	}
	if len(m.MedalName) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintMedal(dAtA, i, uint64(len(m.MedalName)))
		i += copy(dAtA[i:], m.MedalName)
	}
	if m.LiveStatus != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.LiveStatus))
	}
	if m.MasterStatus != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.MasterStatus))
	}
	if m.Status != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Status))
	}
	if m.Reason != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.Reason))
	}
	if m.LastRenameTime != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintMedal(dAtA, i, uint64(m.LastRenameTime))
	}
	if m.IsNull {
		dAtA[i] = 0x48
		i++
		if m.IsNull {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func encodeVarintMedal(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 *MedalCreateReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovMedal(uint64(m.Uid))
	}
	if m.Source != 0 {
		n += 1 + sovMedal(uint64(m.Source))
	}
	return n
}

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

func (m *MedalCreateResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMedal(uint64(m.Id))
	}
	if m.Uid != 0 {
		n += 1 + sovMedal(uint64(m.Uid))
	}
	l = len(m.MedalName)
	if l > 0 {
		n += 1 + l + sovMedal(uint64(l))
	}
	if m.LiveStatus != 0 {
		n += 1 + sovMedal(uint64(m.LiveStatus))
	}
	if m.MasterStatus != 0 {
		n += 1 + sovMedal(uint64(m.MasterStatus))
	}
	if m.Status != 0 {
		n += 1 + sovMedal(uint64(m.Status))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMedal(uint64(l))
	}
	if m.ApplySource != 0 {
		n += 1 + sovMedal(uint64(m.ApplySource))
	}
	if m.LastRenameTime != 0 {
		n += 1 + sovMedal(uint64(m.LastRenameTime))
	}
	if m.RenameStatus != 0 {
		n += 1 + sovMedal(uint64(m.RenameStatus))
	}
	if m.ChargeNum != 0 {
		n += 1 + sovMedal(uint64(m.ChargeNum))
	}
	if m.CoinNum != 0 {
		n += 1 + sovMedal(uint64(m.CoinNum))
	}
	if m.IsNull {
		n += 2
	}
	return n
}

func (m *MedalQueryReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovMedal(uint64(m.Uid))
	}
	if m.Source != 0 {
		n += 1 + sovMedal(uint64(m.Source))
	}
	return n
}

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

func (m *MedalQueryResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMedal(uint64(m.Id))
	}
	if m.Uid != 0 {
		n += 1 + sovMedal(uint64(m.Uid))
	}
	l = len(m.MedalName)
	if l > 0 {
		n += 1 + l + sovMedal(uint64(l))
	}
	if m.LiveStatus != 0 {
		n += 1 + sovMedal(uint64(m.LiveStatus))
	}
	if m.MasterStatus != 0 {
		n += 1 + sovMedal(uint64(m.MasterStatus))
	}
	if m.Status != 0 {
		n += 1 + sovMedal(uint64(m.Status))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMedal(uint64(l))
	}
	if m.ApplySource != 0 {
		n += 1 + sovMedal(uint64(m.ApplySource))
	}
	if m.LastRenameTime != 0 {
		n += 1 + sovMedal(uint64(m.LastRenameTime))
	}
	if m.RenameStatus != 0 {
		n += 1 + sovMedal(uint64(m.RenameStatus))
	}
	if m.ChargeNum != 0 {
		n += 1 + sovMedal(uint64(m.ChargeNum))
	}
	if m.CoinNum != 0 {
		n += 1 + sovMedal(uint64(m.CoinNum))
	}
	if m.IsNull {
		n += 2
	}
	return n
}

func (m *MedalQueryIdReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MedalId != 0 {
		n += 1 + sovMedal(uint64(m.MedalId))
	}
	return n
}

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

func (m *MedalQueryIdResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMedal(uint64(m.Id))
	}
	if m.Uid != 0 {
		n += 1 + sovMedal(uint64(m.Uid))
	}
	l = len(m.MedalName)
	if l > 0 {
		n += 1 + l + sovMedal(uint64(l))
	}
	if m.LiveStatus != 0 {
		n += 1 + sovMedal(uint64(m.LiveStatus))
	}
	if m.MasterStatus != 0 {
		n += 1 + sovMedal(uint64(m.MasterStatus))
	}
	if m.Status != 0 {
		n += 1 + sovMedal(uint64(m.Status))
	}
	if m.Reason != 0 {
		n += 1 + sovMedal(uint64(m.Reason))
	}
	if m.LastRenameTime != 0 {
		n += 1 + sovMedal(uint64(m.LastRenameTime))
	}
	if m.IsNull {
		n += 2
	}
	return n
}

func sovMedal(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozMedal(x uint64) (n int) {
	return sovMedal(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MedalCreateReq) 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 ErrIntOverflowMedal
			}
			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: MedalCreateReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MedalCreateReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalCreateResp) 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 ErrIntOverflowMedal
			}
			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: MedalCreateResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MedalCreateResp: 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 ErrIntOverflowMedal
				}
				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 ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMedal
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &MedalCreateResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalCreateResp_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 ErrIntOverflowMedal
			}
			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 Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 Uid", wireType)
			}
			m.Uid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MedalName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MedalName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiveStatus", wireType)
			}
			m.LiveStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LiveStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterStatus", wireType)
			}
			m.MasterStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MasterStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplySource", wireType)
			}
			m.ApplySource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ApplySource |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastRenameTime", wireType)
			}
			m.LastRenameTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastRenameTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RenameStatus", wireType)
			}
			m.RenameStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RenameStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChargeNum", wireType)
			}
			m.ChargeNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChargeNum |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoinNum", wireType)
			}
			m.CoinNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CoinNum |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNull", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNull = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalQueryReq) 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 ErrIntOverflowMedal
			}
			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: MedalQueryReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MedalQueryReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalQueryResp) 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 ErrIntOverflowMedal
			}
			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: MedalQueryResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MedalQueryResp: 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 ErrIntOverflowMedal
				}
				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 ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMedal
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &MedalQueryResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalQueryResp_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 ErrIntOverflowMedal
			}
			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 Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 Uid", wireType)
			}
			m.Uid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MedalName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MedalName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiveStatus", wireType)
			}
			m.LiveStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LiveStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterStatus", wireType)
			}
			m.MasterStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MasterStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplySource", wireType)
			}
			m.ApplySource = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ApplySource |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastRenameTime", wireType)
			}
			m.LastRenameTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastRenameTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RenameStatus", wireType)
			}
			m.RenameStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RenameStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChargeNum", wireType)
			}
			m.ChargeNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChargeNum |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CoinNum", wireType)
			}
			m.CoinNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CoinNum |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNull", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNull = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalQueryIdResp) 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 ErrIntOverflowMedal
			}
			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: MedalQueryIdResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MedalQueryIdResp: 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 ErrIntOverflowMedal
				}
				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 ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMedal
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &MedalQueryIdResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MedalQueryIdResp_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 ErrIntOverflowMedal
			}
			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 Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 Uid", wireType)
			}
			m.Uid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MedalName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				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 ErrInvalidLengthMedal
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MedalName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiveStatus", wireType)
			}
			m.LiveStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LiveStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterStatus", wireType)
			}
			m.MasterStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MasterStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			m.Reason = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Reason |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastRenameTime", wireType)
			}
			m.LastRenameTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastRenameTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNull", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMedal
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNull = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMedal(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMedal
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func init() { proto.RegisterFile("v1/Medal.proto", fileDescriptor_Medal_320108735012f73b) }

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