openbilibili/library/net/rpc/liverpc/testdata/v2/Room.pb.go

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

package v2

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

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 RoomGetByIdsReq struct {
	Ids               []int64  `protobuf:"varint,1,rep,packed,name=ids,proto3" json:"ids,omitempty"`
	NeedUinfo         int64    `protobuf:"varint,2,opt,name=need_uinfo,json=needUinfo,proto3" json:"need_uinfo,omitempty"`
	NeedBroadcastType int64    `protobuf:"varint,3,opt,name=need_broadcast_type,json=needBroadcastType,proto3" json:"need_broadcast_type,omitempty"`
	Fields            []string `protobuf:"bytes,4,rep,name=fields,proto3" json:"fields,omitempty"`
	From              string   `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
}

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

var xxx_messageInfo_RoomGetByIdsReq proto.InternalMessageInfo

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

func (m *RoomGetByIdsReq) GetNeedUinfo() int64 {
	if m != nil {
		return m.NeedUinfo
	}
	return 0
}

func (m *RoomGetByIdsReq) GetNeedBroadcastType() int64 {
	if m != nil {
		return m.NeedBroadcastType
	}
	return 0
}

func (m *RoomGetByIdsReq) GetFields() []string {
	if m != nil {
		return m.Fields
	}
	return nil
}

func (m *RoomGetByIdsReq) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

type RoomGetByIdsResp struct {
	Code int64                                 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Msg  string                                `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
	Data map[string]*RoomGetByIdsResp_RoomInfo `protobuf:"bytes,3,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_RoomGetByIdsResp proto.InternalMessageInfo

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

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

func (m *RoomGetByIdsResp) GetData() map[string]*RoomGetByIdsResp_RoomInfo {
	if m != nil {
		return m.Data
	}
	return nil
}

type RoomGetByIdsResp_RoomInfo struct {
	Roomid           int64  `protobuf:"varint,1,opt,name=roomid,proto3" json:"roomid,omitempty"`
	Uname            string `protobuf:"bytes,2,opt,name=uname,proto3" json:"uname,omitempty"`
	Face             string `protobuf:"bytes,3,opt,name=face,proto3" json:"face,omitempty"`
	Verify           string `protobuf:"bytes,4,opt,name=verify,proto3" json:"verify,omitempty"`
	Cover            string `protobuf:"bytes,5,opt,name=cover,proto3" json:"cover,omitempty"`
	Uid              int64  `protobuf:"varint,6,opt,name=uid,proto3" json:"uid,omitempty"`
	LiveTime         string `protobuf:"bytes,7,opt,name=live_time,json=liveTime,proto3" json:"live_time,omitempty"`
	RoundStatus      int64  `protobuf:"varint,8,opt,name=round_status,json=roundStatus,proto3" json:"round_status,omitempty"`
	OnFlag           int64  `protobuf:"varint,9,opt,name=on_flag,json=onFlag,proto3" json:"on_flag,omitempty"`
	Title            string `protobuf:"bytes,10,opt,name=title,proto3" json:"title,omitempty"`
	Tags             string `protobuf:"bytes,11,opt,name=tags,proto3" json:"tags,omitempty"`
	LockStatus       string `protobuf:"bytes,12,opt,name=lock_status,json=lockStatus,proto3" json:"lock_status,omitempty"`
	HiddenStatus     string `protobuf:"bytes,13,opt,name=hidden_status,json=hiddenStatus,proto3" json:"hidden_status,omitempty"`
	UserCover        string `protobuf:"bytes,14,opt,name=user_cover,json=userCover,proto3" json:"user_cover,omitempty"`
	ShortId          int64  `protobuf:"varint,15,opt,name=short_id,json=shortId,proto3" json:"short_id,omitempty"`
	Online           int64  `protobuf:"varint,16,opt,name=online,proto3" json:"online,omitempty"`
	Area             int64  `protobuf:"varint,17,opt,name=area,proto3" json:"area,omitempty"`
	AreaV2Id         int64  `protobuf:"varint,18,opt,name=area_v2_id,json=areaV2Id,proto3" json:"area_v2_id,omitempty"`
	AreaV2ParentId   int64  `protobuf:"varint,19,opt,name=area_v2_parent_id,json=areaV2ParentId,proto3" json:"area_v2_parent_id,omitempty"`
	AreaPkStatus     int64  `protobuf:"varint,20,opt,name=area_pk_status,json=areaPkStatus,proto3" json:"area_pk_status,omitempty"`
	AreaV2Name       string `protobuf:"bytes,21,opt,name=area_v2_name,json=areaV2Name,proto3" json:"area_v2_name,omitempty"`
	AreaV2ParentName string `protobuf:"bytes,22,opt,name=area_v2_parent_name,json=areaV2ParentName,proto3" json:"area_v2_parent_name,omitempty"`
	Attentions       int64  `protobuf:"varint,23,opt,name=attentions,proto3" json:"attentions,omitempty"`
	Background       string `protobuf:"bytes,24,opt,name=background,proto3" json:"background,omitempty"`
	RoomSilent       int64  `protobuf:"varint,25,opt,name=room_silent,json=roomSilent,proto3" json:"room_silent,omitempty"`
	RoomShield       int64  `protobuf:"varint,26,opt,name=room_shield,json=roomShield,proto3" json:"room_shield,omitempty"`
	TryTime          string `protobuf:"bytes,27,opt,name=try_time,json=tryTime,proto3" json:"try_time,omitempty"`
	LiveStatus       int64  `protobuf:"varint,28,opt,name=live_status,json=liveStatus,proto3" json:"live_status,omitempty"`
	BroadcastType    int64  `protobuf:"varint,29,opt,name=broadcast_type,json=broadcastType,proto3" json:"broadcast_type,omitempty"`
}

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

var xxx_messageInfo_RoomGetByIdsResp_RoomInfo proto.InternalMessageInfo

func (m *RoomGetByIdsResp_RoomInfo) GetRoomid() int64 {
	if m != nil {
		return m.Roomid
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetUname() string {
	if m != nil {
		return m.Uname
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetFace() string {
	if m != nil {
		return m.Face
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetVerify() string {
	if m != nil {
		return m.Verify
	}
	return ""
}

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

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

func (m *RoomGetByIdsResp_RoomInfo) GetLiveTime() string {
	if m != nil {
		return m.LiveTime
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetRoundStatus() int64 {
	if m != nil {
		return m.RoundStatus
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetOnFlag() int64 {
	if m != nil {
		return m.OnFlag
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetTags() string {
	if m != nil {
		return m.Tags
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetLockStatus() string {
	if m != nil {
		return m.LockStatus
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetHiddenStatus() string {
	if m != nil {
		return m.HiddenStatus
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetUserCover() string {
	if m != nil {
		return m.UserCover
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetShortId() int64 {
	if m != nil {
		return m.ShortId
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetOnline() int64 {
	if m != nil {
		return m.Online
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetArea() int64 {
	if m != nil {
		return m.Area
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetAreaV2Id() int64 {
	if m != nil {
		return m.AreaV2Id
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetAreaV2ParentId() int64 {
	if m != nil {
		return m.AreaV2ParentId
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetAreaPkStatus() int64 {
	if m != nil {
		return m.AreaPkStatus
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetAreaV2Name() string {
	if m != nil {
		return m.AreaV2Name
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetAreaV2ParentName() string {
	if m != nil {
		return m.AreaV2ParentName
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetAttentions() int64 {
	if m != nil {
		return m.Attentions
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetBackground() string {
	if m != nil {
		return m.Background
	}
	return ""
}

func (m *RoomGetByIdsResp_RoomInfo) GetRoomSilent() int64 {
	if m != nil {
		return m.RoomSilent
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetRoomShield() int64 {
	if m != nil {
		return m.RoomShield
	}
	return 0
}

func (m *RoomGetByIdsResp_RoomInfo) GetTryTime() string {
	if m != nil {
		return m.TryTime
	}
	return ""
}

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

func (m *RoomGetByIdsResp_RoomInfo) GetBroadcastType() int64 {
	if m != nil {
		return m.BroadcastType
	}
	return 0
}

func init() {
	proto.RegisterType((*RoomGetByIdsReq)(nil), "room.v2.RoomGetByIdsReq")
	proto.RegisterType((*RoomGetByIdsResp)(nil), "room.v2.RoomGetByIdsResp")
	proto.RegisterMapType((map[string]*RoomGetByIdsResp_RoomInfo)(nil), "room.v2.RoomGetByIdsResp.DataEntry")
	proto.RegisterType((*RoomGetByIdsResp_RoomInfo)(nil), "room.v2.RoomGetByIdsResp.RoomInfo")
}
func (m *RoomGetByIdsReq) 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 *RoomGetByIdsReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Ids) > 0 {
		dAtA2 := make([]byte, len(m.Ids)*10)
		var j1 int
		for _, num1 := range m.Ids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintRoom(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	if m.NeedUinfo != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.NeedUinfo))
	}
	if m.NeedBroadcastType != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.NeedBroadcastType))
	}
	if len(m.Fields) > 0 {
		for _, s := range m.Fields {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.From) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.From)))
		i += copy(dAtA[i:], m.From)
	}
	return i, nil
}

func (m *RoomGetByIdsResp) 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 *RoomGetByIdsResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.Data) > 0 {
		for k, _ := range m.Data {
			dAtA[i] = 0x1a
			i++
			v := m.Data[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovRoom(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovRoom(uint64(len(k))) + msgSize
			i = encodeVarintRoom(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintRoom(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintRoom(dAtA, i, uint64(v.Size()))
				n3, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n3
			}
		}
	}
	return i, nil
}

func (m *RoomGetByIdsResp_RoomInfo) 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 *RoomGetByIdsResp_RoomInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Roomid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.Roomid))
	}
	if len(m.Uname) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Uname)))
		i += copy(dAtA[i:], m.Uname)
	}
	if len(m.Face) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Face)))
		i += copy(dAtA[i:], m.Face)
	}
	if len(m.Verify) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Verify)))
		i += copy(dAtA[i:], m.Verify)
	}
	if len(m.Cover) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Cover)))
		i += copy(dAtA[i:], m.Cover)
	}
	if m.Uid != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.Uid))
	}
	if len(m.LiveTime) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.LiveTime)))
		i += copy(dAtA[i:], m.LiveTime)
	}
	if m.RoundStatus != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.RoundStatus))
	}
	if m.OnFlag != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.OnFlag))
	}
	if len(m.Title) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if len(m.Tags) > 0 {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Tags)))
		i += copy(dAtA[i:], m.Tags)
	}
	if len(m.LockStatus) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.LockStatus)))
		i += copy(dAtA[i:], m.LockStatus)
	}
	if len(m.HiddenStatus) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.HiddenStatus)))
		i += copy(dAtA[i:], m.HiddenStatus)
	}
	if len(m.UserCover) > 0 {
		dAtA[i] = 0x72
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.UserCover)))
		i += copy(dAtA[i:], m.UserCover)
	}
	if m.ShortId != 0 {
		dAtA[i] = 0x78
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.ShortId))
	}
	if m.Online != 0 {
		dAtA[i] = 0x80
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.Online))
	}
	if m.Area != 0 {
		dAtA[i] = 0x88
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.Area))
	}
	if m.AreaV2Id != 0 {
		dAtA[i] = 0x90
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.AreaV2Id))
	}
	if m.AreaV2ParentId != 0 {
		dAtA[i] = 0x98
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.AreaV2ParentId))
	}
	if m.AreaPkStatus != 0 {
		dAtA[i] = 0xa0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.AreaPkStatus))
	}
	if len(m.AreaV2Name) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.AreaV2Name)))
		i += copy(dAtA[i:], m.AreaV2Name)
	}
	if len(m.AreaV2ParentName) > 0 {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.AreaV2ParentName)))
		i += copy(dAtA[i:], m.AreaV2ParentName)
	}
	if m.Attentions != 0 {
		dAtA[i] = 0xb8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.Attentions))
	}
	if len(m.Background) > 0 {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.Background)))
		i += copy(dAtA[i:], m.Background)
	}
	if m.RoomSilent != 0 {
		dAtA[i] = 0xc8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.RoomSilent))
	}
	if m.RoomShield != 0 {
		dAtA[i] = 0xd0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.RoomShield))
	}
	if len(m.TryTime) > 0 {
		dAtA[i] = 0xda
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(len(m.TryTime)))
		i += copy(dAtA[i:], m.TryTime)
	}
	if m.LiveStatus != 0 {
		dAtA[i] = 0xe0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.LiveStatus))
	}
	if m.BroadcastType != 0 {
		dAtA[i] = 0xe8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRoom(dAtA, i, uint64(m.BroadcastType))
	}
	return i, nil
}

func encodeVarintRoom(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 *RoomGetByIdsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ids) > 0 {
		l = 0
		for _, e := range m.Ids {
			l += sovRoom(uint64(e))
		}
		n += 1 + sovRoom(uint64(l)) + l
	}
	if m.NeedUinfo != 0 {
		n += 1 + sovRoom(uint64(m.NeedUinfo))
	}
	if m.NeedBroadcastType != 0 {
		n += 1 + sovRoom(uint64(m.NeedBroadcastType))
	}
	if len(m.Fields) > 0 {
		for _, s := range m.Fields {
			l = len(s)
			n += 1 + l + sovRoom(uint64(l))
		}
	}
	l = len(m.From)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	return n
}

func (m *RoomGetByIdsResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovRoom(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	if len(m.Data) > 0 {
		for k, v := range m.Data {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovRoom(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovRoom(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovRoom(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *RoomGetByIdsResp_RoomInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Roomid != 0 {
		n += 1 + sovRoom(uint64(m.Roomid))
	}
	l = len(m.Uname)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.Face)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.Verify)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.Cover)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	if m.Uid != 0 {
		n += 1 + sovRoom(uint64(m.Uid))
	}
	l = len(m.LiveTime)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	if m.RoundStatus != 0 {
		n += 1 + sovRoom(uint64(m.RoundStatus))
	}
	if m.OnFlag != 0 {
		n += 1 + sovRoom(uint64(m.OnFlag))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.Tags)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.LockStatus)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.HiddenStatus)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	l = len(m.UserCover)
	if l > 0 {
		n += 1 + l + sovRoom(uint64(l))
	}
	if m.ShortId != 0 {
		n += 1 + sovRoom(uint64(m.ShortId))
	}
	if m.Online != 0 {
		n += 2 + sovRoom(uint64(m.Online))
	}
	if m.Area != 0 {
		n += 2 + sovRoom(uint64(m.Area))
	}
	if m.AreaV2Id != 0 {
		n += 2 + sovRoom(uint64(m.AreaV2Id))
	}
	if m.AreaV2ParentId != 0 {
		n += 2 + sovRoom(uint64(m.AreaV2ParentId))
	}
	if m.AreaPkStatus != 0 {
		n += 2 + sovRoom(uint64(m.AreaPkStatus))
	}
	l = len(m.AreaV2Name)
	if l > 0 {
		n += 2 + l + sovRoom(uint64(l))
	}
	l = len(m.AreaV2ParentName)
	if l > 0 {
		n += 2 + l + sovRoom(uint64(l))
	}
	if m.Attentions != 0 {
		n += 2 + sovRoom(uint64(m.Attentions))
	}
	l = len(m.Background)
	if l > 0 {
		n += 2 + l + sovRoom(uint64(l))
	}
	if m.RoomSilent != 0 {
		n += 2 + sovRoom(uint64(m.RoomSilent))
	}
	if m.RoomShield != 0 {
		n += 2 + sovRoom(uint64(m.RoomShield))
	}
	l = len(m.TryTime)
	if l > 0 {
		n += 2 + l + sovRoom(uint64(l))
	}
	if m.LiveStatus != 0 {
		n += 2 + sovRoom(uint64(m.LiveStatus))
	}
	if m.BroadcastType != 0 {
		n += 2 + sovRoom(uint64(m.BroadcastType))
	}
	return n
}

func sovRoom(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRoom(x uint64) (n int) {
	return sovRoom(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RoomGetByIdsReq) 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 ErrIntOverflowRoom
			}
			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: RoomGetByIdsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RoomGetByIdsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRoom
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Ids = append(m.Ids, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRoom
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthRoom
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Ids) == 0 {
					m.Ids = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRoom
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Ids = append(m.Ids, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeedUinfo", wireType)
			}
			m.NeedUinfo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NeedUinfo |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeedBroadcastType", wireType)
			}
			m.NeedBroadcastType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NeedBroadcastType |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.From = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRoom(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRoom
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RoomGetByIdsResp) 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 ErrIntOverflowRoom
			}
			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: RoomGetByIdsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RoomGetByIdsResp: 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 ErrIntOverflowRoom
				}
				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 ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			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 ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRoom
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = make(map[string]*RoomGetByIdsResp_RoomInfo)
			}
			var mapkey string
			var mapvalue *RoomGetByIdsResp_RoomInfo
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRoom
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRoom
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthRoom
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRoom
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthRoom
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthRoom
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &RoomGetByIdsResp_RoomInfo{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipRoom(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthRoom
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Data[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRoom(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRoom
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RoomGetByIdsResp_RoomInfo) 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 ErrIntOverflowRoom
			}
			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: RoomInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RoomInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Roomid", wireType)
			}
			m.Roomid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Roomid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Uname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Face", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Face = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Verify", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Verify = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cover", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cover = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
			}
			m.Uid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiveTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LiveTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoundStatus", wireType)
			}
			m.RoundStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoundStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnFlag", wireType)
			}
			m.OnFlag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnFlag |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tags = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockStatus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LockStatus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HiddenStatus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HiddenStatus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserCover", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserCover = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShortId", wireType)
			}
			m.ShortId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShortId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Online", wireType)
			}
			m.Online = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Online |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Area", wireType)
			}
			m.Area = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Area |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AreaV2Id", wireType)
			}
			m.AreaV2Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AreaV2Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AreaV2ParentId", wireType)
			}
			m.AreaV2ParentId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AreaV2ParentId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AreaPkStatus", wireType)
			}
			m.AreaPkStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AreaPkStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AreaV2Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AreaV2Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AreaV2ParentName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AreaV2ParentName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 23:
			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 ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Attentions |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Background", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Background = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomSilent", wireType)
			}
			m.RoomSilent = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomSilent |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 26:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomShield", wireType)
			}
			m.RoomShield = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomShield |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TryTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				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 ErrInvalidLengthRoom
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TryTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 28:
			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 ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LiveStatus |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BroadcastType", wireType)
			}
			m.BroadcastType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoom
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BroadcastType |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoom(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRoom
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func init() { proto.RegisterFile("v2/Room.proto", fileDescriptor_Room_dd99878fba5dfa8c) }

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