openbilibili/app/interface/main/activity/model/timemachine/timemachine.pb.go

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

package timemachine

import proto "github.com/golang/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.ProtoPackageIsVersion2 // please upgrade the proto package

type Item struct {
	Mid                  int64    `protobuf:"varint,1,opt,name=Mid,proto3" json:"mid"`
	IsUp                 int64    `protobuf:"varint,2,opt,name=IsUp,proto3" json:"is_up"`
	DurationHour         int64    `protobuf:"varint,3,opt,name=DurationHour,proto3" json:"duration_hour"`
	AvDurationHour       int64    `protobuf:"varint,4,opt,name=AvDurationHour,proto3" json:"av_duration_hour"`
	ArchiveVv            int64    `protobuf:"varint,5,opt,name=ArchiveVv,proto3" json:"archive_vv"`
	LikeTagID            int64    `protobuf:"varint,6,opt,name=LikeTagID,proto3" json:"like_tag_id"`
	LikeSubtidVv         int64    `protobuf:"varint,7,opt,name=LikeSubtidVv,proto3" json:"like_subtid_vv"`
	LikesUgc3Avids       string   `protobuf:"bytes,8,opt,name=LikesUgc3Avids,proto3" json:"likes_ugc_3avids"`
	LikePgc3Avids        string   `protobuf:"bytes,9,opt,name=LikePgc3Avids,proto3" json:"like_pgc_3avids"`
	LikeBestUpID         int64    `protobuf:"varint,10,opt,name=LikeBestUpID,proto3" json:"like_best_upid"`
	LikeUpAvDuration     int64    `protobuf:"varint,11,opt,name=LikeUpAvDuration,proto3" json:"like_up_av_duration"`
	LikeUpLiveDuration   int64    `protobuf:"varint,12,opt,name=LikeUpLiveDuration,proto3" json:"like_up_live_duration"`
	LikeUp3Avs           string   `protobuf:"bytes,13,opt,name=LikeUp3Avs,proto3" json:"like_up_3avs"`
	LikeLiveUpSubTname   string   `protobuf:"bytes,14,opt,name=LikeLiveUpSubTname,proto3" json:"like_live_up_sub_tname"`
	BrainwashCirTime     string   `protobuf:"bytes,15,opt,name=BrainwashCirTime,proto3" json:"brainwash_cir_time"`
	BrainwashCirAvid     int64    `protobuf:"varint,16,opt,name=BrainwashCirAvid,proto3" json:"brainwash_cir_avid"`
	BrainwashCirVv       int64    `protobuf:"varint,17,opt,name=BrainwashCirVv,proto3" json:"brainwash_cir_vv"`
	FirstSubmitAvid      int64    `protobuf:"varint,18,opt,name=FirstSubmitAvid,proto3" json:"first_submit_avid"`
	FirstSubmitTime      string   `protobuf:"bytes,19,opt,name=FirstSubmitTime,proto3" json:"first_submit_time"`
	FirstSubmitType      int64    `protobuf:"varint,20,opt,name=FirstSubmitType,proto3" json:"first_submit_type"`
	SubmitAvsRds         string   `protobuf:"bytes,21,opt,name=SubmitAvsRds,proto3" json:"submit_avs_rds"`
	BestAvid             int64    `protobuf:"varint,22,opt,name=BestAvid,proto3" json:"best_avid"`
	BestAvidType         int64    `protobuf:"varint,23,opt,name=BestAvidType,proto3" json:"best_avid_type"`
	BestAvidOld          int64    `protobuf:"varint,24,opt,name=BestAvidOld,proto3" json:"best_avid_old"`
	BestAvidOldType      int64    `protobuf:"varint,25,opt,name=BestAvidOldType,proto3" json:"best_avid_old_type"`
	OldAvVv              int64    `protobuf:"varint,26,opt,name=OldAvVv,proto3" json:"old_av_vv"`
	AllVv                int64    `protobuf:"varint,27,opt,name=AllVv,proto3" json:"all_vv"`
	UpLiveDuration       int64    `protobuf:"varint,28,opt,name=UpLiveDuration,proto3" json:"up_live_duration"`
	IsLiveUp             int64    `protobuf:"varint,29,opt,name=IsLiveUp,proto3" json:"is_live_up"`
	ValidLiveDays        int64    `protobuf:"varint,30,opt,name=ValidLiveDays,proto3" json:"valid_live_days"`
	MaxCdnNumDate        string   `protobuf:"bytes,31,opt,name=MaxCdnNumDate,proto3" json:"max_cdn_num_date"`
	MaxCdnNum            int64    `protobuf:"varint,32,opt,name=MaxCdnNum,proto3" json:"max_cdn_num"`
	Attentions           int64    `protobuf:"varint,33,opt,name=Attentions,proto3" json:"attentions"`
	UpBestFanVv          string   `protobuf:"bytes,34,opt,name=UpBestFanVv,proto3" json:"up_best_fan_vv"`
	UpBestFanLiveMinute  string   `protobuf:"bytes,35,opt,name=UpBestFanLiveMinute,proto3" json:"up_best_fan_live_minute"`
	Like2Tids            string   `protobuf:"bytes,36,opt,name=Like2Tids,proto3" json:"like_2tids"`
	Like2SubTids         string   `protobuf:"bytes,37,opt,name=Like2subTids,proto3" json:"like_2sub_tids"`
	WinRatio             string   `protobuf:"bytes,38,opt,name=WinRatio,proto3" json:"win_ratio"`
	PlayDurationHourRep  int64    `protobuf:"varint,39,opt,name=PlayDurationHourRep,proto3" json:"play_duration_hour_rep"`
	LikeUpAvDurationRep  int64    `protobuf:"varint,40,opt,name=LikeUpAvDurationRep,proto3" json:"like_up_av_duration_rep"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Item proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Item)(nil), "activity.job.Item")
}
func (m *Item) 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 *Item) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.Mid))
	}
	if m.IsUp != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.IsUp))
	}
	if m.DurationHour != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.DurationHour))
	}
	if m.AvDurationHour != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.AvDurationHour))
	}
	if m.ArchiveVv != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.ArchiveVv))
	}
	if m.LikeTagID != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.LikeTagID))
	}
	if m.LikeSubtidVv != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.LikeSubtidVv))
	}
	if len(m.LikesUgc3Avids) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.LikesUgc3Avids)))
		i += copy(dAtA[i:], m.LikesUgc3Avids)
	}
	if len(m.LikePgc3Avids) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.LikePgc3Avids)))
		i += copy(dAtA[i:], m.LikePgc3Avids)
	}
	if m.LikeBestUpID != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.LikeBestUpID))
	}
	if m.LikeUpAvDuration != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.LikeUpAvDuration))
	}
	if m.LikeUpLiveDuration != 0 {
		dAtA[i] = 0x60
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.LikeUpLiveDuration))
	}
	if len(m.LikeUp3Avs) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.LikeUp3Avs)))
		i += copy(dAtA[i:], m.LikeUp3Avs)
	}
	if len(m.LikeLiveUpSubTname) > 0 {
		dAtA[i] = 0x72
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.LikeLiveUpSubTname)))
		i += copy(dAtA[i:], m.LikeLiveUpSubTname)
	}
	if len(m.BrainwashCirTime) > 0 {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.BrainwashCirTime)))
		i += copy(dAtA[i:], m.BrainwashCirTime)
	}
	if m.BrainwashCirAvid != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.BrainwashCirAvid))
	}
	if m.BrainwashCirVv != 0 {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.BrainwashCirVv))
	}
	if m.FirstSubmitAvid != 0 {
		dAtA[i] = 0x90
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.FirstSubmitAvid))
	}
	if len(m.FirstSubmitTime) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.FirstSubmitTime)))
		i += copy(dAtA[i:], m.FirstSubmitTime)
	}
	if m.FirstSubmitType != 0 {
		dAtA[i] = 0xa0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.FirstSubmitType))
	}
	if len(m.SubmitAvsRds) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.SubmitAvsRds)))
		i += copy(dAtA[i:], m.SubmitAvsRds)
	}
	if m.BestAvid != 0 {
		dAtA[i] = 0xb0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.BestAvid))
	}
	if m.BestAvidType != 0 {
		dAtA[i] = 0xb8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.BestAvidType))
	}
	if m.BestAvidOld != 0 {
		dAtA[i] = 0xc0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.BestAvidOld))
	}
	if m.BestAvidOldType != 0 {
		dAtA[i] = 0xc8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.BestAvidOldType))
	}
	if m.OldAvVv != 0 {
		dAtA[i] = 0xd0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.OldAvVv))
	}
	if m.AllVv != 0 {
		dAtA[i] = 0xd8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.AllVv))
	}
	if m.UpLiveDuration != 0 {
		dAtA[i] = 0xe0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.UpLiveDuration))
	}
	if m.IsLiveUp != 0 {
		dAtA[i] = 0xe8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.IsLiveUp))
	}
	if m.ValidLiveDays != 0 {
		dAtA[i] = 0xf0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.ValidLiveDays))
	}
	if len(m.MaxCdnNumDate) > 0 {
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.MaxCdnNumDate)))
		i += copy(dAtA[i:], m.MaxCdnNumDate)
	}
	if m.MaxCdnNum != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.MaxCdnNum))
	}
	if m.Attentions != 0 {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.Attentions))
	}
	if len(m.UpBestFanVv) > 0 {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.UpBestFanVv)))
		i += copy(dAtA[i:], m.UpBestFanVv)
	}
	if len(m.UpBestFanLiveMinute) > 0 {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.UpBestFanLiveMinute)))
		i += copy(dAtA[i:], m.UpBestFanLiveMinute)
	}
	if len(m.Like2Tids) > 0 {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.Like2Tids)))
		i += copy(dAtA[i:], m.Like2Tids)
	}
	if len(m.Like2SubTids) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.Like2SubTids)))
		i += copy(dAtA[i:], m.Like2SubTids)
	}
	if len(m.WinRatio) > 0 {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(len(m.WinRatio)))
		i += copy(dAtA[i:], m.WinRatio)
	}
	if m.PlayDurationHourRep != 0 {
		dAtA[i] = 0xb8
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.PlayDurationHourRep))
	}
	if m.LikeUpAvDurationRep != 0 {
		dAtA[i] = 0xc0
		i++
		dAtA[i] = 0x2
		i++
		i = encodeVarintTimemachine(dAtA, i, uint64(m.LikeUpAvDurationRep))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintTimemachine(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 *Item) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovTimemachine(uint64(m.Mid))
	}
	if m.IsUp != 0 {
		n += 1 + sovTimemachine(uint64(m.IsUp))
	}
	if m.DurationHour != 0 {
		n += 1 + sovTimemachine(uint64(m.DurationHour))
	}
	if m.AvDurationHour != 0 {
		n += 1 + sovTimemachine(uint64(m.AvDurationHour))
	}
	if m.ArchiveVv != 0 {
		n += 1 + sovTimemachine(uint64(m.ArchiveVv))
	}
	if m.LikeTagID != 0 {
		n += 1 + sovTimemachine(uint64(m.LikeTagID))
	}
	if m.LikeSubtidVv != 0 {
		n += 1 + sovTimemachine(uint64(m.LikeSubtidVv))
	}
	l = len(m.LikesUgc3Avids)
	if l > 0 {
		n += 1 + l + sovTimemachine(uint64(l))
	}
	l = len(m.LikePgc3Avids)
	if l > 0 {
		n += 1 + l + sovTimemachine(uint64(l))
	}
	if m.LikeBestUpID != 0 {
		n += 1 + sovTimemachine(uint64(m.LikeBestUpID))
	}
	if m.LikeUpAvDuration != 0 {
		n += 1 + sovTimemachine(uint64(m.LikeUpAvDuration))
	}
	if m.LikeUpLiveDuration != 0 {
		n += 1 + sovTimemachine(uint64(m.LikeUpLiveDuration))
	}
	l = len(m.LikeUp3Avs)
	if l > 0 {
		n += 1 + l + sovTimemachine(uint64(l))
	}
	l = len(m.LikeLiveUpSubTname)
	if l > 0 {
		n += 1 + l + sovTimemachine(uint64(l))
	}
	l = len(m.BrainwashCirTime)
	if l > 0 {
		n += 1 + l + sovTimemachine(uint64(l))
	}
	if m.BrainwashCirAvid != 0 {
		n += 2 + sovTimemachine(uint64(m.BrainwashCirAvid))
	}
	if m.BrainwashCirVv != 0 {
		n += 2 + sovTimemachine(uint64(m.BrainwashCirVv))
	}
	if m.FirstSubmitAvid != 0 {
		n += 2 + sovTimemachine(uint64(m.FirstSubmitAvid))
	}
	l = len(m.FirstSubmitTime)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	if m.FirstSubmitType != 0 {
		n += 2 + sovTimemachine(uint64(m.FirstSubmitType))
	}
	l = len(m.SubmitAvsRds)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	if m.BestAvid != 0 {
		n += 2 + sovTimemachine(uint64(m.BestAvid))
	}
	if m.BestAvidType != 0 {
		n += 2 + sovTimemachine(uint64(m.BestAvidType))
	}
	if m.BestAvidOld != 0 {
		n += 2 + sovTimemachine(uint64(m.BestAvidOld))
	}
	if m.BestAvidOldType != 0 {
		n += 2 + sovTimemachine(uint64(m.BestAvidOldType))
	}
	if m.OldAvVv != 0 {
		n += 2 + sovTimemachine(uint64(m.OldAvVv))
	}
	if m.AllVv != 0 {
		n += 2 + sovTimemachine(uint64(m.AllVv))
	}
	if m.UpLiveDuration != 0 {
		n += 2 + sovTimemachine(uint64(m.UpLiveDuration))
	}
	if m.IsLiveUp != 0 {
		n += 2 + sovTimemachine(uint64(m.IsLiveUp))
	}
	if m.ValidLiveDays != 0 {
		n += 2 + sovTimemachine(uint64(m.ValidLiveDays))
	}
	l = len(m.MaxCdnNumDate)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	if m.MaxCdnNum != 0 {
		n += 2 + sovTimemachine(uint64(m.MaxCdnNum))
	}
	if m.Attentions != 0 {
		n += 2 + sovTimemachine(uint64(m.Attentions))
	}
	l = len(m.UpBestFanVv)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	l = len(m.UpBestFanLiveMinute)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	l = len(m.Like2Tids)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	l = len(m.Like2SubTids)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	l = len(m.WinRatio)
	if l > 0 {
		n += 2 + l + sovTimemachine(uint64(l))
	}
	if m.PlayDurationHourRep != 0 {
		n += 2 + sovTimemachine(uint64(m.PlayDurationHourRep))
	}
	if m.LikeUpAvDurationRep != 0 {
		n += 2 + sovTimemachine(uint64(m.LikeUpAvDurationRep))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovTimemachine(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozTimemachine(x uint64) (n int) {
	return sovTimemachine(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Item) 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 ErrIntOverflowTimemachine
			}
			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: Item: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Item: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsUp", wireType)
			}
			m.IsUp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsUp |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DurationHour", wireType)
			}
			m.DurationHour = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DurationHour |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvDurationHour", wireType)
			}
			m.AvDurationHour = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvDurationHour |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArchiveVv", wireType)
			}
			m.ArchiveVv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArchiveVv |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeTagID", wireType)
			}
			m.LikeTagID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LikeTagID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeSubtidVv", wireType)
			}
			m.LikeSubtidVv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LikeSubtidVv |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikesUgc3Avids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LikesUgc3Avids = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikePgc3Avids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LikePgc3Avids = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeBestUpID", wireType)
			}
			m.LikeBestUpID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LikeBestUpID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeUpAvDuration", wireType)
			}
			m.LikeUpAvDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LikeUpAvDuration |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeUpLiveDuration", wireType)
			}
			m.LikeUpLiveDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LikeUpLiveDuration |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeUp3Avs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LikeUp3Avs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeLiveUpSubTname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LikeLiveUpSubTname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BrainwashCirTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BrainwashCirTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BrainwashCirAvid", wireType)
			}
			m.BrainwashCirAvid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BrainwashCirAvid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BrainwashCirVv", wireType)
			}
			m.BrainwashCirVv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BrainwashCirVv |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstSubmitAvid", wireType)
			}
			m.FirstSubmitAvid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstSubmitAvid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstSubmitTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FirstSubmitTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstSubmitType", wireType)
			}
			m.FirstSubmitType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstSubmitType |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmitAvsRds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubmitAvsRds = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestAvid", wireType)
			}
			m.BestAvid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BestAvid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestAvidType", wireType)
			}
			m.BestAvidType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BestAvidType |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestAvidOld", wireType)
			}
			m.BestAvidOld = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BestAvidOld |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BestAvidOldType", wireType)
			}
			m.BestAvidOldType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BestAvidOldType |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 26:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldAvVv", wireType)
			}
			m.OldAvVv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OldAvVv |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 27:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllVv", wireType)
			}
			m.AllVv = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AllVv |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 28:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpLiveDuration", wireType)
			}
			m.UpLiveDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpLiveDuration |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLiveUp", wireType)
			}
			m.IsLiveUp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsLiveUp |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidLiveDays", wireType)
			}
			m.ValidLiveDays = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ValidLiveDays |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxCdnNumDate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MaxCdnNumDate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxCdnNum", wireType)
			}
			m.MaxCdnNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxCdnNum |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 33:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attentions", wireType)
			}
			m.Attentions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Attentions |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpBestFanVv", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpBestFanVv = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpBestFanLiveMinute", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UpBestFanLiveMinute = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Like2Tids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Like2Tids = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Like2SubTids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Like2SubTids = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WinRatio", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				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 ErrInvalidLengthTimemachine
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WinRatio = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 39:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlayDurationHourRep", wireType)
			}
			m.PlayDurationHourRep = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PlayDurationHourRep |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 40:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LikeUpAvDurationRep", wireType)
			}
			m.LikeUpAvDurationRep = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTimemachine
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LikeUpAvDurationRep |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTimemachine(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTimemachine
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

func init() { proto.RegisterFile("timemachine.proto", fileDescriptor_timemachine_bbd2f85a30f70dd8) }

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