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

package v1

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 (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

// Bar请求
type Bar1Req struct {
	// 用户uid
	//
	// aaa
	Uid                  int32    `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid"`
	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_demo_4b2170f3d67b04fe, []int{0}
}
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_demo_4b2170f3d67b04fe, []int{1}
}
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_demo_4b2170f3d67b04fe, []int{1, 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_demo_4b2170f3d67b04fe, []int{2}
}
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_demo_4b2170f3d67b04fe, []int{3}
}
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((*Bar1Req)(nil), "live.livedemo.v1.Bar1Req")
	proto.RegisterType((*Bar1Resp)(nil), "live.livedemo.v1.Bar1Resp")
	proto.RegisterMapType((map[string]*Bar1Resp_List)(nil), "live.livedemo.v1.Bar1Resp.AmapEntry")
	proto.RegisterType((*Bar1Resp_List)(nil), "live.livedemo.v1.Bar1Resp.List")
	proto.RegisterType((*GetInfoReq)(nil), "live.livedemo.v1.GetInfoReq")
	proto.RegisterType((*GetInfoResp)(nil), "live.livedemo.v1.GetInfoResp")
	proto.RegisterMapType((map[int32]string)(nil), "live.livedemo.v1.GetInfoResp.AmapEntry")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// FooClient is the client API for Foo service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type FooClient interface {
	// 根据uid得到uname
	// `method:"post" midware:"auth,verify"`
	//
	// 这是详细说明
	UnameByUid(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error)
	// 获取房间信息
	// `midware:"guest"`
	GetInfo(ctx context.Context, in *GetInfoReq, opts ...grpc.CallOption) (*GetInfoResp, error)
	// 根据uid得到uname v3
	UnameByUid3(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error)
	// test comment
	// `internal:"true"`
	UnameByUid4(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error)
	// `dynamic_resp:"true"`
	GetDynamic(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error)
	// `dynamic:"true"`
	Nointerface(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error)
}

type fooClient struct {
	cc *grpc.ClientConn
}

func NewFooClient(cc *grpc.ClientConn) FooClient {
	return &fooClient{cc}
}

func (c *fooClient) UnameByUid(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error) {
	out := new(Bar1Resp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo/uname_by_uid", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fooClient) GetInfo(ctx context.Context, in *GetInfoReq, opts ...grpc.CallOption) (*GetInfoResp, error) {
	out := new(GetInfoResp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo/get_info", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fooClient) UnameByUid3(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error) {
	out := new(Bar1Resp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo/uname_by_uid3", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fooClient) UnameByUid4(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error) {
	out := new(Bar1Resp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo/uname_by_uid4", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fooClient) GetDynamic(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error) {
	out := new(Bar1Resp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo/get_dynamic", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *fooClient) Nointerface(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error) {
	out := new(Bar1Resp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo/nointerface", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// FooServer is the server API for Foo service.
type FooServer interface {
	// 根据uid得到uname
	// `method:"post" midware:"auth,verify"`
	//
	// 这是详细说明
	UnameByUid(context.Context, *Bar1Req) (*Bar1Resp, error)
	// 获取房间信息
	// `midware:"guest"`
	GetInfo(context.Context, *GetInfoReq) (*GetInfoResp, error)
	// 根据uid得到uname v3
	UnameByUid3(context.Context, *Bar1Req) (*Bar1Resp, error)
	// test comment
	// `internal:"true"`
	UnameByUid4(context.Context, *Bar1Req) (*Bar1Resp, error)
	// `dynamic_resp:"true"`
	GetDynamic(context.Context, *Bar1Req) (*Bar1Resp, error)
	// `dynamic:"true"`
	Nointerface(context.Context, *Bar1Req) (*Bar1Resp, error)
}

func RegisterFooServer(s *grpc.Server, srv FooServer) {
	s.RegisterService(&_Foo_serviceDesc, srv)
}

func _Foo_UnameByUid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Bar1Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FooServer).UnameByUid(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo/UnameByUid",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FooServer).UnameByUid(ctx, req.(*Bar1Req))
	}
	return interceptor(ctx, in, info, handler)
}

func _Foo_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FooServer).GetInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo/GetInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FooServer).GetInfo(ctx, req.(*GetInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Foo_UnameByUid3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Bar1Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FooServer).UnameByUid3(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo/UnameByUid3",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FooServer).UnameByUid3(ctx, req.(*Bar1Req))
	}
	return interceptor(ctx, in, info, handler)
}

func _Foo_UnameByUid4_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Bar1Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FooServer).UnameByUid4(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo/UnameByUid4",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FooServer).UnameByUid4(ctx, req.(*Bar1Req))
	}
	return interceptor(ctx, in, info, handler)
}

func _Foo_GetDynamic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Bar1Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FooServer).GetDynamic(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo/GetDynamic",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FooServer).GetDynamic(ctx, req.(*Bar1Req))
	}
	return interceptor(ctx, in, info, handler)
}

func _Foo_Nointerface_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Bar1Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FooServer).Nointerface(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo/Nointerface",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FooServer).Nointerface(ctx, req.(*Bar1Req))
	}
	return interceptor(ctx, in, info, handler)
}

var _Foo_serviceDesc = grpc.ServiceDesc{
	ServiceName: "live.livedemo.v1.Foo",
	HandlerType: (*FooServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "uname_by_uid",
			Handler:    _Foo_UnameByUid_Handler,
		},
		{
			MethodName: "get_info",
			Handler:    _Foo_GetInfo_Handler,
		},
		{
			MethodName: "uname_by_uid3",
			Handler:    _Foo_UnameByUid3_Handler,
		},
		{
			MethodName: "uname_by_uid4",
			Handler:    _Foo_UnameByUid4_Handler,
		},
		{
			MethodName: "get_dynamic",
			Handler:    _Foo_GetDynamic_Handler,
		},
		{
			MethodName: "nointerface",
			Handler:    _Foo_Nointerface_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "demo.proto",
}

// Foo2Client is the client API for Foo2 service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type Foo2Client interface {
	Hello(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error)
}

type foo2Client struct {
	cc *grpc.ClientConn
}

func NewFoo2Client(cc *grpc.ClientConn) Foo2Client {
	return &foo2Client{cc}
}

func (c *foo2Client) Hello(ctx context.Context, in *Bar1Req, opts ...grpc.CallOption) (*Bar1Resp, error) {
	out := new(Bar1Resp)
	err := c.cc.Invoke(ctx, "/live.livedemo.v1.Foo2/hello", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Foo2Server is the server API for Foo2 service.
type Foo2Server interface {
	Hello(context.Context, *Bar1Req) (*Bar1Resp, error)
}

func RegisterFoo2Server(s *grpc.Server, srv Foo2Server) {
	s.RegisterService(&_Foo2_serviceDesc, srv)
}

func _Foo2_Hello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Bar1Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(Foo2Server).Hello(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.livedemo.v1.Foo2/Hello",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(Foo2Server).Hello(ctx, req.(*Bar1Req))
	}
	return interceptor(ctx, in, info, handler)
}

var _Foo2_serviceDesc = grpc.ServiceDesc{
	ServiceName: "live.livedemo.v1.Foo2",
	HandlerType: (*Foo2Server)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "hello",
			Handler:    _Foo2_Hello_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "demo.proto",
}

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 = encodeVarintDemo(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 = encodeVarintDemo(dAtA, i, uint64(len(m.Uname)))
		i += copy(dAtA[i:], m.Uname)
	}
	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] = 0x1a
		i++
		i = encodeVarintDemo(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	if len(m.List) > 0 {
		for _, msg := range m.List {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDemo(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 = encodeVarintDemo(dAtA, i, uint64(m.Alist.Size()))
		n3, err := m.Alist.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	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 + sovDemo(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovDemo(uint64(len(k))) + msgSize
			i = encodeVarintDemo(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintDemo(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintDemo(dAtA, i, uint64(v.Size()))
				n4, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n4
			}
		}
	}
	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 = encodeVarintDemo(dAtA, i, uint64(len(m.Hello)))
		i += copy(dAtA[i:], m.Hello)
	}
	if len(m.World) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDemo(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 = encodeVarintDemo(dAtA, i, uint64(m.RoomId))
	}
	if len(m.ManyIds) > 0 {
		dAtA6 := make([]byte, len(m.ManyIds)*10)
		var j5 int
		for _, num1 := range m.ManyIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintDemo(dAtA, i, uint64(j5))
		i += copy(dAtA[i:], dAtA6[:j5])
	}
	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 = encodeVarintDemo(dAtA, i, uint64(m.Roomid))
	}
	if len(m.Uname) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDemo(dAtA, i, uint64(len(m.Uname)))
		i += copy(dAtA[i:], m.Uname)
	}
	if len(m.LiveTime) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDemo(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 + sovDemo(uint64(k)) + 1 + len(v) + sovDemo(uint64(len(v)))
			i = encodeVarintDemo(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintDemo(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintDemo(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 = encodeVarintDemo(dAtA, i, uint64(m.Mid))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintDemo(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 *Bar1Req) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovDemo(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 + sovDemo(uint64(l))
	}
	if len(m.Ids) > 0 {
		l = 0
		for _, e := range m.Ids {
			l += sovDemo(uint64(e))
		}
		n += 1 + sovDemo(uint64(l)) + l
	}
	if len(m.List) > 0 {
		for _, e := range m.List {
			l = e.Size()
			n += 1 + l + sovDemo(uint64(l))
		}
	}
	if m.Alist != nil {
		l = m.Alist.Size()
		n += 1 + l + sovDemo(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 + sovDemo(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovDemo(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovDemo(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 + sovDemo(uint64(l))
	}
	l = len(m.World)
	if l > 0 {
		n += 1 + l + sovDemo(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 + sovDemo(uint64(m.RoomId))
	}
	if len(m.ManyIds) > 0 {
		l = 0
		for _, e := range m.ManyIds {
			l += sovDemo(uint64(e))
		}
		n += 1 + sovDemo(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 + sovDemo(uint64(m.Roomid))
	}
	l = len(m.Uname)
	if l > 0 {
		n += 1 + l + sovDemo(uint64(l))
	}
	l = len(m.LiveTime)
	if l > 0 {
		n += 1 + l + sovDemo(uint64(l))
	}
	if len(m.Amap) > 0 {
		for k, v := range m.Amap {
			_ = k
			_ = v
			mapEntrySize := 1 + sovDemo(uint64(k)) + 1 + len(v) + sovDemo(uint64(len(v)))
			n += mapEntrySize + 1 + sovDemo(uint64(mapEntrySize))
		}
	}
	if m.Rate != 0 {
		n += 5
	}
	if m.Mid != 0 {
		n += 1 + sovDemo(uint64(m.Mid))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovDemo(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozDemo(x uint64) (n int) {
	return sovDemo(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
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 ErrIntOverflowDemo
			}
			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 ErrIntOverflowDemo
				}
				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 := skipDemo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
			}
			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 ErrIntOverflowDemo
				}
				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 ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
					}
					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 ErrIntOverflowDemo
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDemo
				}
				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 ErrIntOverflowDemo
						}
						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 ErrIntOverflowDemo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
					}
					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 ErrIntOverflowDemo
						}
						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 ErrInvalidLengthDemo
					}
					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 ErrIntOverflowDemo
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthDemo
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthDemo
					}
					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 := skipDemo(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthDemo
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Amap[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDemo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
			}
			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 ErrIntOverflowDemo
				}
				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 ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
				}
				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 ErrInvalidLengthDemo
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.World = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDemo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
			}
			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 ErrIntOverflowDemo
				}
				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 ErrIntOverflowDemo
					}
					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 ErrIntOverflowDemo
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDemo
				}
				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 ErrIntOverflowDemo
						}
						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 := skipDemo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
			}
			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 ErrIntOverflowDemo
				}
				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 ErrIntOverflowDemo
				}
				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 ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
				}
				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 ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDemo
			}
			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 ErrIntOverflowDemo
					}
					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 ErrIntOverflowDemo
						}
						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 ErrIntOverflowDemo
						}
						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 ErrInvalidLengthDemo
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDemo(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthDemo
					}
					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 ErrIntOverflowDemo
				}
				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 := skipDemo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDemo
			}
			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 skipDemo(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, ErrIntOverflowDemo
			}
			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, ErrIntOverflowDemo
				}
				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, ErrIntOverflowDemo
				}
				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, ErrInvalidLengthDemo
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowDemo
					}
					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 := skipDemo(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 (
	ErrInvalidLengthDemo = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDemo   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("demo.proto", fileDescriptor_demo_4b2170f3d67b04fe) }

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