openbilibili/app/interface/live/live-demo/api/http/v2/service.pb.go

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

package v2

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import _ "google.golang.org/genproto/googleapis/api/annotations"

import encoding_binary "encoding/binary"

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 JsonReq struct {
	// json请求参数
	P1                   string          `protobuf:"bytes,1,opt,name=p1,proto3" json:"p1,omitempty"`
	P2                   *JsonSubMessage `protobuf:"bytes,2,opt,name=p2" json:"p2,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_JsonReq proto.InternalMessageInfo

func (m *JsonReq) GetP1() string {
	if m != nil {
		return m.P1
	}
	return ""
}

func (m *JsonReq) GetP2() *JsonSubMessage {
	if m != nil {
		return m.P2
	}
	return nil
}

type JsonSubMessage struct {
	// param
	Param                string   `protobuf:"bytes,1,opt,name=param,proto3" json:"param,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_JsonSubMessage proto.InternalMessageInfo

func (m *JsonSubMessage) GetParam() string {
	if m != nil {
		return m.Param
	}
	return ""
}

type JsonResp struct {
	// json请求响应
	P1                   string   `protobuf:"bytes,1,opt,name=p1,proto3" json:"p1,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_JsonResp proto.InternalMessageInfo

func (m *JsonResp) GetP1() string {
	if m != nil {
		return m.P1
	}
	return ""
}

// Bar请求
type Bar1Req struct {
	// 用户uid
	Uid                  int32    `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"required"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Bar1Req proto.InternalMessageInfo

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

// Bar 相应
type Bar1Resp struct {
	// 用户名
	// `mock:"hello"`
	Uname string `protobuf:"bytes,2,opt,name=uname,proto3" json:"uname"`
	// idshaha
	// `mock:"343242"`
	Ids                  []int32                   `protobuf:"varint,3,rep,packed,name=ids" json:"ids"`
	List                 []*Bar1Resp_List          `protobuf:"bytes,4,rep,name=list" json:"list"`
	Alist                *Bar1Resp_List            `protobuf:"bytes,5,opt,name=alist" json:"alist"`
	Amap                 map[string]*Bar1Resp_List `protobuf:"bytes,6,rep,name=amap" json:"amap" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_Bar1Resp proto.InternalMessageInfo

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

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

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

func (m *Bar1Resp) GetAlist() *Bar1Resp_List {
	if m != nil {
		return m.Alist
	}
	return nil
}

func (m *Bar1Resp) GetAmap() map[string]*Bar1Resp_List {
	if m != nil {
		return m.Amap
	}
	return nil
}

type Bar1Resp_List struct {
	// `mock:"\"withquote"`
	Hello                string   `protobuf:"bytes,1,opt,name=hello,proto3" json:"hello"`
	World                string   `protobuf:"bytes,2,opt,name=world,proto3" json:"world"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Bar1Resp_List) Reset()         { *m = Bar1Resp_List{} }
func (m *Bar1Resp_List) String() string { return proto.CompactTextString(m) }
func (*Bar1Resp_List) ProtoMessage()    {}
func (*Bar1Resp_List) Descriptor() ([]byte, []int) {
	return fileDescriptor_service_9c3ebddd56b8b8a3, []int{4, 0}
}
func (m *Bar1Resp_List) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Bar1Resp_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Bar1Resp_List.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Bar1Resp_List) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bar1Resp_List.Merge(dst, src)
}
func (m *Bar1Resp_List) XXX_Size() int {
	return m.Size()
}
func (m *Bar1Resp_List) XXX_DiscardUnknown() {
	xxx_messageInfo_Bar1Resp_List.DiscardUnknown(m)
}

var xxx_messageInfo_Bar1Resp_List proto.InternalMessageInfo

func (m *Bar1Resp_List) GetHello() string {
	if m != nil {
		return m.Hello
	}
	return ""
}

func (m *Bar1Resp_List) GetWorld() string {
	if m != nil {
		return m.World
	}
	return ""
}

// 获取房间信息请求
type GetInfoReq struct {
	// 房间id
	// `mock:"123"
	RoomId               int64    `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id,omitempty" form:"room_id" validate:"required"`
	ManyIds              []int64  `protobuf:"varint,2,rep,packed,name=many_ids,json=manyIds" json:"many_ids,omitempty" form:"many_ids"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetInfoReq proto.InternalMessageInfo

func (m *GetInfoReq) GetRoomId() int64 {
	if m != nil {
		return m.RoomId
	}
	return 0
}

func (m *GetInfoReq) GetManyIds() []int64 {
	if m != nil {
		return m.ManyIds
	}
	return nil
}

// 获取房间信息响应
type GetInfoResp struct {
	// 房间id 注释貌似只有放在前面才能被识别，放到字段声明后面是没用的
	Roomid int64 `protobuf:"varint,1,opt,name=roomid,proto3" json:"roomid"`
	// 用户名
	Uname string `protobuf:"bytes,2,opt,name=uname,proto3" json:"uname"`
	// 开播时间
	LiveTime string           `protobuf:"bytes,3,opt,name=live_time,json=liveTime,proto3" json:"live_time"`
	Amap     map[int32]string `protobuf:"bytes,4,rep,name=amap" json:"amap" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// `mock:"6.02214129e23"`
	Rate float32 `protobuf:"fixed32,5,opt,name=rate,proto3" json:"rate"`
	// 用户mid
	Mid                  int64    `protobuf:"varint,6,opt,name=mid,proto3" json:"mid"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetInfoResp proto.InternalMessageInfo

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

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

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

func (m *GetInfoResp) GetAmap() map[int32]string {
	if m != nil {
		return m.Amap
	}
	return nil
}

func (m *GetInfoResp) GetRate() float32 {
	if m != nil {
		return m.Rate
	}
	return 0
}

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

func init() {
	proto.RegisterType((*JsonReq)(nil), "live.livedemo.v2.JsonReq")
	proto.RegisterType((*JsonSubMessage)(nil), "live.livedemo.v2.JsonSubMessage")
	proto.RegisterType((*JsonResp)(nil), "live.livedemo.v2.JsonResp")
	proto.RegisterType((*Bar1Req)(nil), "live.livedemo.v2.Bar1Req")
	proto.RegisterType((*Bar1Resp)(nil), "live.livedemo.v2.Bar1Resp")
	proto.RegisterMapType((map[string]*Bar1Resp_List)(nil), "live.livedemo.v2.Bar1Resp.AmapEntry")
	proto.RegisterType((*Bar1Resp_List)(nil), "live.livedemo.v2.Bar1Resp.List")
	proto.RegisterType((*GetInfoReq)(nil), "live.livedemo.v2.GetInfoReq")
	proto.RegisterType((*GetInfoResp)(nil), "live.livedemo.v2.GetInfoResp")
	proto.RegisterMapType((map[int32]string)(nil), "live.livedemo.v2.GetInfoResp.AmapEntry")
}
func (m *JsonReq) 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 *JsonReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.P1) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.P1)))
		i += copy(dAtA[i:], m.P1)
	}
	if m.P2 != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(m.P2.Size()))
		n1, err := m.P2.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

func (m *Bar1Resp) 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 *Bar1Resp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Uname) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Uname)))
		i += copy(dAtA[i:], m.Uname)
	}
	if len(m.Ids) > 0 {
		dAtA3 := make([]byte, len(m.Ids)*10)
		var j2 int
		for _, num1 := range m.Ids {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintService(dAtA, i, uint64(j2))
		i += copy(dAtA[i:], dAtA3[:j2])
	}
	if len(m.List) > 0 {
		for _, msg := range m.List {
			dAtA[i] = 0x22
			i++
			i = encodeVarintService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Alist != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Alist.Size()))
		n4, err := m.Alist.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if len(m.Amap) > 0 {
		for k, _ := range m.Amap {
			dAtA[i] = 0x32
			i++
			v := m.Amap[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovService(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovService(uint64(len(k))) + msgSize
			i = encodeVarintService(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintService(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintService(dAtA, i, uint64(v.Size()))
				n5, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n5
			}
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Bar1Resp_List) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Bar1Resp_List) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Hello) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Hello)))
		i += copy(dAtA[i:], m.Hello)
	}
	if len(m.World) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.World)))
		i += copy(dAtA[i:], m.World)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetInfoReq) 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 *GetInfoReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RoomId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintService(dAtA, i, uint64(m.RoomId))
	}
	if len(m.ManyIds) > 0 {
		dAtA7 := make([]byte, len(m.ManyIds)*10)
		var j6 int
		for _, num1 := range m.ManyIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(j6))
		i += copy(dAtA[i:], dAtA7[:j6])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GetInfoResp) 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 *GetInfoResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Roomid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Roomid))
	}
	if len(m.Uname) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.Uname)))
		i += copy(dAtA[i:], m.Uname)
	}
	if len(m.LiveTime) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintService(dAtA, i, uint64(len(m.LiveTime)))
		i += copy(dAtA[i:], m.LiveTime)
	}
	if len(m.Amap) > 0 {
		for k, _ := range m.Amap {
			dAtA[i] = 0x22
			i++
			v := m.Amap[k]
			mapSize := 1 + sovService(uint64(k)) + 1 + len(v) + sovService(uint64(len(v)))
			i = encodeVarintService(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintService(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintService(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if m.Rate != 0 {
		dAtA[i] = 0x2d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rate))))
		i += 4
	}
	if m.Mid != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintService(dAtA, i, uint64(m.Mid))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintService(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 *JsonReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.P1)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.P2 != nil {
		l = m.P2.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *JsonSubMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Param)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *JsonResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.P1)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Bar1Resp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Uname)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Ids) > 0 {
		l = 0
		for _, e := range m.Ids {
			l += sovService(uint64(e))
		}
		n += 1 + sovService(uint64(l)) + l
	}
	if len(m.List) > 0 {
		for _, e := range m.List {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	if m.Alist != nil {
		l = m.Alist.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Amap) > 0 {
		for k, v := range m.Amap {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovService(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovService(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovService(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Bar1Resp_List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hello)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.World)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *GetInfoResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Roomid != 0 {
		n += 1 + sovService(uint64(m.Roomid))
	}
	l = len(m.Uname)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.LiveTime)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if len(m.Amap) > 0 {
		for k, v := range m.Amap {
			_ = k
			_ = v
			mapEntrySize := 1 + sovService(uint64(k)) + 1 + len(v) + sovService(uint64(len(v)))
			n += mapEntrySize + 1 + sovService(uint64(mapEntrySize))
		}
	}
	if m.Rate != 0 {
		n += 5
	}
	if m.Mid != 0 {
		n += 1 + sovService(uint64(m.Mid))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovService(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *JsonReq) 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 ErrIntOverflowService
			}
			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: JsonReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JsonReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.P1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.P2 == nil {
				m.P2 = &JsonSubMessage{}
			}
			if err := m.P2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JsonSubMessage) 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 ErrIntOverflowService
			}
			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: JsonSubMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JsonSubMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Param", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Param = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JsonResp) 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 ErrIntOverflowService
			}
			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: JsonResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JsonResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field P1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.P1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Bar1Resp) 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 ErrIntOverflowService
			}
			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: Bar1Resp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bar1Resp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Uname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int32(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 ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthService
				}
				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([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int32(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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.List = append(m.List, &Bar1Resp_List{})
			if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Alist", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Alist == nil {
				m.Alist = &Bar1Resp_List{}
			}
			if err := m.Alist.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Amap == nil {
				m.Amap = make(map[string]*Bar1Resp_List)
			}
			var mapkey string
			var mapvalue *Bar1Resp_List
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					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 ErrIntOverflowService
						}
						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 ErrInvalidLengthService
					}
					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 ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthService
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthService
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Bar1Resp_List{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Amap[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Bar1Resp_List) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowService
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hello", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hello = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field World", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.World = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetInfoReq) 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 ErrIntOverflowService
			}
			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: GetInfoReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetInfoReq: 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 ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ManyIds = append(m.ManyIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthService
				}
				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.ManyIds) == 0 {
					m.ManyIds = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ManyIds = append(m.ManyIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ManyIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetInfoResp) 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 ErrIntOverflowService
			}
			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: GetInfoResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetInfoResp: 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 ErrIntOverflowService
				}
				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 ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			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 LiveTime", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LiveTime = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Amap == nil {
				m.Amap = make(map[int32]string)
			}
			var mapkey int32
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthService
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Amap[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rate = float32(math.Float32frombits(v))
		case 6:
			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 ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthService
			}
			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 skipService(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, ErrIntOverflowService
			}
			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, ErrIntOverflowService
				}
				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, ErrIntOverflowService
				}
				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, ErrInvalidLengthService
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowService
					}
					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 := skipService(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 (
	ErrInvalidLengthService = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("service.proto", fileDescriptor_service_9c3ebddd56b8b8a3) }

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