// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/main/broadcast/api/grpc/v1/api.proto

/*
	Package v1 is a generated protocol buffer package.

	It is generated from these files:
		app/service/main/broadcast/api/grpc/v1/api.proto

	It has these top-level messages:
		CloseReply
		CloseReq
		PingReply
		PingReq
		ConnectReq
		ConnectReply
		DisconnectReq
		DisconnectReply
		HeartbeatReq
		HeartbeatReply
		OnlineReq
		OnlineReply
		ReceiveReq
		ReceiveReply
		ServerListReq
		ServerListReply
		Backoff
*/
package v1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import push_service_broadcast_model "go-common/app/service/main/broadcast/model"

import context "golang.org/x/net/context"
import grpc "google.golang.org/grpc"

import 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 CloseReply struct {
}

func (m *CloseReply) Reset()                    { *m = CloseReply{} }
func (m *CloseReply) String() string            { return proto.CompactTextString(m) }
func (*CloseReply) ProtoMessage()               {}
func (*CloseReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} }

type CloseReq struct {
}

func (m *CloseReq) Reset()                    { *m = CloseReq{} }
func (m *CloseReq) String() string            { return proto.CompactTextString(m) }
func (*CloseReq) ProtoMessage()               {}
func (*CloseReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }

type PingReply struct {
}

func (m *PingReply) Reset()                    { *m = PingReply{} }
func (m *PingReply) String() string            { return proto.CompactTextString(m) }
func (*PingReply) ProtoMessage()               {}
func (*PingReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2} }

type PingReq struct {
}

func (m *PingReq) Reset()                    { *m = PingReq{} }
func (m *PingReq) String() string            { return proto.CompactTextString(m) }
func (*PingReq) ProtoMessage()               {}
func (*PingReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{3} }

type ConnectReq struct {
	Server    string `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	ServerKey string `protobuf:"bytes,2,opt,name=serverKey,proto3" json:"serverKey,omitempty"`
	Cookie    string `protobuf:"bytes,3,opt,name=cookie,proto3" json:"cookie,omitempty"`
	Token     []byte `protobuf:"bytes,4,opt,name=token,proto3" json:"token,omitempty"`
}

func (m *ConnectReq) Reset()                    { *m = ConnectReq{} }
func (*ConnectReq) ProtoMessage()               {}
func (*ConnectReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{4} }

func (m *ConnectReq) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *ConnectReq) GetServerKey() string {
	if m != nil {
		return m.ServerKey
	}
	return ""
}

func (m *ConnectReq) GetCookie() string {
	if m != nil {
		return m.Cookie
	}
	return ""
}

func (m *ConnectReq) GetToken() []byte {
	if m != nil {
		return m.Token
	}
	return nil
}

type ConnectReply struct {
	Mid      int64   `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Key      string  `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	RoomID   string  `protobuf:"bytes,3,opt,name=roomID,proto3" json:"roomID,omitempty"`
	Platform string  `protobuf:"bytes,4,opt,name=platform,proto3" json:"platform,omitempty"`
	Accepts  []int32 `protobuf:"varint,5,rep,packed,name=accepts" json:"accepts,omitempty"`
}

func (m *ConnectReply) Reset()                    { *m = ConnectReply{} }
func (m *ConnectReply) String() string            { return proto.CompactTextString(m) }
func (*ConnectReply) ProtoMessage()               {}
func (*ConnectReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{5} }

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

func (m *ConnectReply) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *ConnectReply) GetRoomID() string {
	if m != nil {
		return m.RoomID
	}
	return ""
}

func (m *ConnectReply) GetPlatform() string {
	if m != nil {
		return m.Platform
	}
	return ""
}

func (m *ConnectReply) GetAccepts() []int32 {
	if m != nil {
		return m.Accepts
	}
	return nil
}

type DisconnectReq struct {
	Mid    int64  `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Key    string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Server string `protobuf:"bytes,3,opt,name=server,proto3" json:"server,omitempty"`
}

func (m *DisconnectReq) Reset()                    { *m = DisconnectReq{} }
func (m *DisconnectReq) String() string            { return proto.CompactTextString(m) }
func (*DisconnectReq) ProtoMessage()               {}
func (*DisconnectReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{6} }

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

func (m *DisconnectReq) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *DisconnectReq) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

type DisconnectReply struct {
	Has bool `protobuf:"varint,1,opt,name=has,proto3" json:"has,omitempty"`
}

func (m *DisconnectReply) Reset()                    { *m = DisconnectReply{} }
func (m *DisconnectReply) String() string            { return proto.CompactTextString(m) }
func (*DisconnectReply) ProtoMessage()               {}
func (*DisconnectReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{7} }

func (m *DisconnectReply) GetHas() bool {
	if m != nil {
		return m.Has
	}
	return false
}

type HeartbeatReq struct {
	Mid    int64  `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Key    string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Server string `protobuf:"bytes,3,opt,name=server,proto3" json:"server,omitempty"`
}

func (m *HeartbeatReq) Reset()                    { *m = HeartbeatReq{} }
func (m *HeartbeatReq) String() string            { return proto.CompactTextString(m) }
func (*HeartbeatReq) ProtoMessage()               {}
func (*HeartbeatReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{8} }

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

func (m *HeartbeatReq) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *HeartbeatReq) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

type HeartbeatReply struct {
}

func (m *HeartbeatReply) Reset()                    { *m = HeartbeatReply{} }
func (m *HeartbeatReply) String() string            { return proto.CompactTextString(m) }
func (*HeartbeatReply) ProtoMessage()               {}
func (*HeartbeatReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{9} }

type OnlineReq struct {
	Server    string           `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	RoomCount map[string]int32 `protobuf:"bytes,2,rep,name=roomCount" json:"roomCount,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Sharding  int32            `protobuf:"varint,3,opt,name=sharding,proto3" json:"sharding,omitempty"`
}

func (m *OnlineReq) Reset()                    { *m = OnlineReq{} }
func (*OnlineReq) ProtoMessage()               {}
func (*OnlineReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{10} }

func (m *OnlineReq) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *OnlineReq) GetRoomCount() map[string]int32 {
	if m != nil {
		return m.RoomCount
	}
	return nil
}

func (m *OnlineReq) GetSharding() int32 {
	if m != nil {
		return m.Sharding
	}
	return 0
}

type OnlineReply struct {
	RoomCount map[string]int32 `protobuf:"bytes,1,rep,name=roomCount" json:"roomCount,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
}

func (m *OnlineReply) Reset()                    { *m = OnlineReply{} }
func (*OnlineReply) ProtoMessage()               {}
func (*OnlineReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{11} }

func (m *OnlineReply) GetRoomCount() map[string]int32 {
	if m != nil {
		return m.RoomCount
	}
	return nil
}

type ReceiveReq struct {
	Mid   int64                               `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"`
	Proto *push_service_broadcast_model.Proto `protobuf:"bytes,2,opt,name=proto" json:"proto,omitempty"`
}

func (m *ReceiveReq) Reset()                    { *m = ReceiveReq{} }
func (m *ReceiveReq) String() string            { return proto.CompactTextString(m) }
func (*ReceiveReq) ProtoMessage()               {}
func (*ReceiveReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{12} }

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

func (m *ReceiveReq) GetProto() *push_service_broadcast_model.Proto {
	if m != nil {
		return m.Proto
	}
	return nil
}

type ReceiveReply struct {
	Proto *push_service_broadcast_model.Proto `protobuf:"bytes,1,opt,name=proto" json:"proto,omitempty"`
}

func (m *ReceiveReply) Reset()                    { *m = ReceiveReply{} }
func (m *ReceiveReply) String() string            { return proto.CompactTextString(m) }
func (*ReceiveReply) ProtoMessage()               {}
func (*ReceiveReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{13} }

func (m *ReceiveReply) GetProto() *push_service_broadcast_model.Proto {
	if m != nil {
		return m.Proto
	}
	return nil
}

type ServerListReq struct {
	Platform string `protobuf:"bytes,1,opt,name=platform,proto3" json:"platform,omitempty"`
}

func (m *ServerListReq) Reset()                    { *m = ServerListReq{} }
func (m *ServerListReq) String() string            { return proto.CompactTextString(m) }
func (*ServerListReq) ProtoMessage()               {}
func (*ServerListReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{14} }

func (m *ServerListReq) GetPlatform() string {
	if m != nil {
		return m.Platform
	}
	return ""
}

type ServerListReply struct {
	Domain       string   `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain"`
	TcpPort      int32    `protobuf:"varint,2,opt,name=tcpPort,proto3" json:"tcp_port"`
	WsPort       int32    `protobuf:"varint,3,opt,name=wsPort,proto3" json:"ws_port"`
	WssPort      int32    `protobuf:"varint,4,opt,name=wssPort,proto3" json:"wss_port"`
	Heartbeat    int32    `protobuf:"varint,5,opt,name=heartbeat,proto3" json:"heartbeat"`
	Nodes        []string `protobuf:"bytes,6,rep,name=nodes" json:"nodes"`
	Backoff      *Backoff `protobuf:"bytes,7,opt,name=backoff" json:"backoff"`
	HeartbeatMax int32    `protobuf:"varint,8,opt,name=heartbeatMax,proto3" json:"heartbeat_max"`
}

func (m *ServerListReply) Reset()                    { *m = ServerListReply{} }
func (m *ServerListReply) String() string            { return proto.CompactTextString(m) }
func (*ServerListReply) ProtoMessage()               {}
func (*ServerListReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{15} }

func (m *ServerListReply) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *ServerListReply) GetTcpPort() int32 {
	if m != nil {
		return m.TcpPort
	}
	return 0
}

func (m *ServerListReply) GetWsPort() int32 {
	if m != nil {
		return m.WsPort
	}
	return 0
}

func (m *ServerListReply) GetWssPort() int32 {
	if m != nil {
		return m.WssPort
	}
	return 0
}

func (m *ServerListReply) GetHeartbeat() int32 {
	if m != nil {
		return m.Heartbeat
	}
	return 0
}

func (m *ServerListReply) GetNodes() []string {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *ServerListReply) GetBackoff() *Backoff {
	if m != nil {
		return m.Backoff
	}
	return nil
}

func (m *ServerListReply) GetHeartbeatMax() int32 {
	if m != nil {
		return m.HeartbeatMax
	}
	return 0
}

type Backoff struct {
	MaxDelay  int32   `protobuf:"varint,1,opt,name=MaxDelay,proto3" json:"max_delay"`
	BaseDelay int32   `protobuf:"varint,2,opt,name=BaseDelay,proto3" json:"base_delay"`
	Factor    float32 `protobuf:"fixed32,3,opt,name=Factor,proto3" json:"factor"`
	Jitter    float32 `protobuf:"fixed32,4,opt,name=Jitter,proto3" json:"jitter"`
}

func (m *Backoff) Reset()                    { *m = Backoff{} }
func (m *Backoff) String() string            { return proto.CompactTextString(m) }
func (*Backoff) ProtoMessage()               {}
func (*Backoff) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{16} }

func (m *Backoff) GetMaxDelay() int32 {
	if m != nil {
		return m.MaxDelay
	}
	return 0
}

func (m *Backoff) GetBaseDelay() int32 {
	if m != nil {
		return m.BaseDelay
	}
	return 0
}

func (m *Backoff) GetFactor() float32 {
	if m != nil {
		return m.Factor
	}
	return 0
}

func (m *Backoff) GetJitter() float32 {
	if m != nil {
		return m.Jitter
	}
	return 0
}

func init() {
	proto.RegisterType((*CloseReply)(nil), "push.service.broadcast.CloseReply")
	proto.RegisterType((*CloseReq)(nil), "push.service.broadcast.CloseReq")
	proto.RegisterType((*PingReply)(nil), "push.service.broadcast.PingReply")
	proto.RegisterType((*PingReq)(nil), "push.service.broadcast.PingReq")
	proto.RegisterType((*ConnectReq)(nil), "push.service.broadcast.ConnectReq")
	proto.RegisterType((*ConnectReply)(nil), "push.service.broadcast.ConnectReply")
	proto.RegisterType((*DisconnectReq)(nil), "push.service.broadcast.DisconnectReq")
	proto.RegisterType((*DisconnectReply)(nil), "push.service.broadcast.DisconnectReply")
	proto.RegisterType((*HeartbeatReq)(nil), "push.service.broadcast.HeartbeatReq")
	proto.RegisterType((*HeartbeatReply)(nil), "push.service.broadcast.HeartbeatReply")
	proto.RegisterType((*OnlineReq)(nil), "push.service.broadcast.OnlineReq")
	proto.RegisterType((*OnlineReply)(nil), "push.service.broadcast.OnlineReply")
	proto.RegisterType((*ReceiveReq)(nil), "push.service.broadcast.ReceiveReq")
	proto.RegisterType((*ReceiveReply)(nil), "push.service.broadcast.ReceiveReply")
	proto.RegisterType((*ServerListReq)(nil), "push.service.broadcast.ServerListReq")
	proto.RegisterType((*ServerListReply)(nil), "push.service.broadcast.ServerListReply")
	proto.RegisterType((*Backoff)(nil), "push.service.broadcast.Backoff")
}

// 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

// Client API for Zerg service

type ZergClient interface {
	// Ping Service
	Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingReply, error)
	// Close Service
	Close(ctx context.Context, in *CloseReq, opts ...grpc.CallOption) (*CloseReply, error)
	// Connect
	Connect(ctx context.Context, in *ConnectReq, opts ...grpc.CallOption) (*ConnectReply, error)
	// Disconnect
	Disconnect(ctx context.Context, in *DisconnectReq, opts ...grpc.CallOption) (*DisconnectReply, error)
	// Heartbeat
	Heartbeat(ctx context.Context, in *HeartbeatReq, opts ...grpc.CallOption) (*HeartbeatReply, error)
	// RenewOnline
	RenewOnline(ctx context.Context, in *OnlineReq, opts ...grpc.CallOption) (*OnlineReply, error)
	// Receive
	Receive(ctx context.Context, in *ReceiveReq, opts ...grpc.CallOption) (*ReceiveReply, error)
	// ServerList
	ServerList(ctx context.Context, in *ServerListReq, opts ...grpc.CallOption) (*ServerListReply, error)
}

type zergClient struct {
	cc *grpc.ClientConn
}

func NewZergClient(cc *grpc.ClientConn) ZergClient {
	return &zergClient{cc}
}

func (c *zergClient) Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingReply, error) {
	out := new(PingReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/Ping", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) Close(ctx context.Context, in *CloseReq, opts ...grpc.CallOption) (*CloseReply, error) {
	out := new(CloseReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/Close", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) Connect(ctx context.Context, in *ConnectReq, opts ...grpc.CallOption) (*ConnectReply, error) {
	out := new(ConnectReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/Connect", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) Disconnect(ctx context.Context, in *DisconnectReq, opts ...grpc.CallOption) (*DisconnectReply, error) {
	out := new(DisconnectReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/Disconnect", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) Heartbeat(ctx context.Context, in *HeartbeatReq, opts ...grpc.CallOption) (*HeartbeatReply, error) {
	out := new(HeartbeatReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/Heartbeat", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) RenewOnline(ctx context.Context, in *OnlineReq, opts ...grpc.CallOption) (*OnlineReply, error) {
	out := new(OnlineReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/RenewOnline", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) Receive(ctx context.Context, in *ReceiveReq, opts ...grpc.CallOption) (*ReceiveReply, error) {
	out := new(ReceiveReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/Receive", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zergClient) ServerList(ctx context.Context, in *ServerListReq, opts ...grpc.CallOption) (*ServerListReply, error) {
	out := new(ServerListReply)
	err := grpc.Invoke(ctx, "/push.service.broadcast.Zerg/ServerList", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Zerg service

type ZergServer interface {
	// Ping Service
	Ping(context.Context, *PingReq) (*PingReply, error)
	// Close Service
	Close(context.Context, *CloseReq) (*CloseReply, error)
	// Connect
	Connect(context.Context, *ConnectReq) (*ConnectReply, error)
	// Disconnect
	Disconnect(context.Context, *DisconnectReq) (*DisconnectReply, error)
	// Heartbeat
	Heartbeat(context.Context, *HeartbeatReq) (*HeartbeatReply, error)
	// RenewOnline
	RenewOnline(context.Context, *OnlineReq) (*OnlineReply, error)
	// Receive
	Receive(context.Context, *ReceiveReq) (*ReceiveReply, error)
	// ServerList
	ServerList(context.Context, *ServerListReq) (*ServerListReply, error)
}

func RegisterZergServer(s *grpc.Server, srv ZergServer) {
	s.RegisterService(&_Zerg_serviceDesc, srv)
}

func _Zerg_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).Ping(ctx, req.(*PingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).Close(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/Close",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).Close(ctx, req.(*CloseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_Connect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).Connect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/Connect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).Connect(ctx, req.(*ConnectReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_Disconnect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DisconnectReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).Disconnect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/Disconnect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).Disconnect(ctx, req.(*DisconnectReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_Heartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HeartbeatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).Heartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/Heartbeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).Heartbeat(ctx, req.(*HeartbeatReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_RenewOnline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OnlineReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).RenewOnline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/RenewOnline",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).RenewOnline(ctx, req.(*OnlineReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_Receive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReceiveReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).Receive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/Receive",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).Receive(ctx, req.(*ReceiveReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Zerg_ServerList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZergServer).ServerList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/push.service.broadcast.Zerg/ServerList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZergServer).ServerList(ctx, req.(*ServerListReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Zerg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "push.service.broadcast.Zerg",
	HandlerType: (*ZergServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _Zerg_Ping_Handler,
		},
		{
			MethodName: "Close",
			Handler:    _Zerg_Close_Handler,
		},
		{
			MethodName: "Connect",
			Handler:    _Zerg_Connect_Handler,
		},
		{
			MethodName: "Disconnect",
			Handler:    _Zerg_Disconnect_Handler,
		},
		{
			MethodName: "Heartbeat",
			Handler:    _Zerg_Heartbeat_Handler,
		},
		{
			MethodName: "RenewOnline",
			Handler:    _Zerg_RenewOnline_Handler,
		},
		{
			MethodName: "Receive",
			Handler:    _Zerg_Receive_Handler,
		},
		{
			MethodName: "ServerList",
			Handler:    _Zerg_ServerList_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/main/broadcast/api/grpc/v1/api.proto",
}

func (m *CloseReply) 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 *CloseReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *CloseReq) 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 *CloseReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *PingReply) 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 *PingReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *PingReq) 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 *PingReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ConnectReq) 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 *ConnectReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Server) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Server)))
		i += copy(dAtA[i:], m.Server)
	}
	if len(m.ServerKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.ServerKey)))
		i += copy(dAtA[i:], m.ServerKey)
	}
	if len(m.Cookie) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Cookie)))
		i += copy(dAtA[i:], m.Cookie)
	}
	if len(m.Token) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Token)))
		i += copy(dAtA[i:], m.Token)
	}
	return i, nil
}

func (m *ConnectReply) 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 *ConnectReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.RoomID) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.RoomID)))
		i += copy(dAtA[i:], m.RoomID)
	}
	if len(m.Platform) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Platform)))
		i += copy(dAtA[i:], m.Platform)
	}
	if len(m.Accepts) > 0 {
		dAtA2 := make([]byte, len(m.Accepts)*10)
		var j1 int
		for _, num1 := range m.Accepts {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	return i, nil
}

func (m *DisconnectReq) 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 *DisconnectReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Server) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Server)))
		i += copy(dAtA[i:], m.Server)
	}
	return i, nil
}

func (m *DisconnectReply) 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 *DisconnectReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Has {
		dAtA[i] = 0x8
		i++
		if m.Has {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *HeartbeatReq) 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 *HeartbeatReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Server) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Server)))
		i += copy(dAtA[i:], m.Server)
	}
	return i, nil
}

func (m *HeartbeatReply) 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 *HeartbeatReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *OnlineReq) 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 *OnlineReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Server) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Server)))
		i += copy(dAtA[i:], m.Server)
	}
	if len(m.RoomCount) > 0 {
		for k, _ := range m.RoomCount {
			dAtA[i] = 0x12
			i++
			v := m.RoomCount[k]
			mapSize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v))
			i = encodeVarintApi(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintApi(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintApi(dAtA, i, uint64(v))
		}
	}
	if m.Sharding != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Sharding))
	}
	return i, nil
}

func (m *OnlineReply) 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 *OnlineReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.RoomCount) > 0 {
		for k, _ := range m.RoomCount {
			dAtA[i] = 0xa
			i++
			v := m.RoomCount[k]
			mapSize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v))
			i = encodeVarintApi(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintApi(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintApi(dAtA, i, uint64(v))
		}
	}
	return i, nil
}

func (m *ReceiveReq) 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 *ReceiveReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Mid))
	}
	if m.Proto != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Proto.Size()))
		n3, err := m.Proto.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

func (m *ReceiveReply) 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 *ReceiveReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Proto != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Proto.Size()))
		n4, err := m.Proto.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

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

func (m *ServerListReply) 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 *ServerListReply) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Domain) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Domain)))
		i += copy(dAtA[i:], m.Domain)
	}
	if m.TcpPort != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.TcpPort))
	}
	if m.WsPort != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.WsPort))
	}
	if m.WssPort != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.WssPort))
	}
	if m.Heartbeat != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Heartbeat))
	}
	if len(m.Nodes) > 0 {
		for _, s := range m.Nodes {
			dAtA[i] = 0x32
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Backoff != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Backoff.Size()))
		n5, err := m.Backoff.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.HeartbeatMax != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.HeartbeatMax))
	}
	return i, nil
}

func (m *Backoff) 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 *Backoff) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MaxDelay != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.MaxDelay))
	}
	if m.BaseDelay != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.BaseDelay))
	}
	if m.Factor != 0 {
		dAtA[i] = 0x1d
		i++
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Factor))))
		i += 4
	}
	if m.Jitter != 0 {
		dAtA[i] = 0x25
		i++
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Jitter))))
		i += 4
	}
	return i, nil
}

func encodeVarintApi(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 *CloseReply) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *CloseReq) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *PingReply) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *PingReq) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ConnectReq) Size() (n int) {
	var l int
	_ = l
	l = len(m.Server)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.ServerKey)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Cookie)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *ConnectReply) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.RoomID)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Platform)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if len(m.Accepts) > 0 {
		l = 0
		for _, e := range m.Accepts {
			l += sovApi(uint64(e))
		}
		n += 1 + sovApi(uint64(l)) + l
	}
	return n
}

func (m *DisconnectReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Server)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *DisconnectReply) Size() (n int) {
	var l int
	_ = l
	if m.Has {
		n += 2
	}
	return n
}

func (m *HeartbeatReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.Server)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *HeartbeatReply) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *OnlineReq) Size() (n int) {
	var l int
	_ = l
	l = len(m.Server)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if len(m.RoomCount) > 0 {
		for k, v := range m.RoomCount {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v))
			n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize))
		}
	}
	if m.Sharding != 0 {
		n += 1 + sovApi(uint64(m.Sharding))
	}
	return n
}

func (m *OnlineReply) Size() (n int) {
	var l int
	_ = l
	if len(m.RoomCount) > 0 {
		for k, v := range m.RoomCount {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v))
			n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ReceiveReq) Size() (n int) {
	var l int
	_ = l
	if m.Mid != 0 {
		n += 1 + sovApi(uint64(m.Mid))
	}
	if m.Proto != nil {
		l = m.Proto.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *ReceiveReply) Size() (n int) {
	var l int
	_ = l
	if m.Proto != nil {
		l = m.Proto.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *ServerListReq) Size() (n int) {
	var l int
	_ = l
	l = len(m.Platform)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *ServerListReply) Size() (n int) {
	var l int
	_ = l
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.TcpPort != 0 {
		n += 1 + sovApi(uint64(m.TcpPort))
	}
	if m.WsPort != 0 {
		n += 1 + sovApi(uint64(m.WsPort))
	}
	if m.WssPort != 0 {
		n += 1 + sovApi(uint64(m.WssPort))
	}
	if m.Heartbeat != 0 {
		n += 1 + sovApi(uint64(m.Heartbeat))
	}
	if len(m.Nodes) > 0 {
		for _, s := range m.Nodes {
			l = len(s)
			n += 1 + l + sovApi(uint64(l))
		}
	}
	if m.Backoff != nil {
		l = m.Backoff.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.HeartbeatMax != 0 {
		n += 1 + sovApi(uint64(m.HeartbeatMax))
	}
	return n
}

func (m *Backoff) Size() (n int) {
	var l int
	_ = l
	if m.MaxDelay != 0 {
		n += 1 + sovApi(uint64(m.MaxDelay))
	}
	if m.BaseDelay != 0 {
		n += 1 + sovApi(uint64(m.BaseDelay))
	}
	if m.Factor != 0 {
		n += 5
	}
	if m.Jitter != 0 {
		n += 5
	}
	return n
}

func sovApi(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CloseReply) 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 ErrIntOverflowApi
			}
			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: CloseReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloseReq) 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 ErrIntOverflowApi
			}
			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: CloseReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PingReply) 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 ErrIntOverflowApi
			}
			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: PingReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PingReq) 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 ErrIntOverflowApi
			}
			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: PingReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PingReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectReq) 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 ErrIntOverflowApi
			}
			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: ConnectReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Server = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServerKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cookie", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cookie = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = append(m.Token[:0], dAtA[iNdEx:postIndex]...)
			if m.Token == nil {
				m.Token = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectReply) 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 ErrIntOverflowApi
			}
			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: ConnectReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RoomID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Platform = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int32(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Accepts = append(m.Accepts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthApi
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Accepts = append(m.Accepts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Accepts", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DisconnectReq) 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 ErrIntOverflowApi
			}
			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: DisconnectReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DisconnectReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Server = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartbeatReq) 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 ErrIntOverflowApi
			}
			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: HeartbeatReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Server = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartbeatReply) 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 ErrIntOverflowApi
			}
			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: HeartbeatReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OnlineReq) 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 ErrIntOverflowApi
			}
			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: OnlineReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OnlineReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Server = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomCount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RoomCount == nil {
				m.RoomCount = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					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 ErrIntOverflowApi
						}
						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 ErrInvalidLengthApi
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipApi(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthApi
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RoomCount[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sharding", wireType)
			}
			m.Sharding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sharding |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OnlineReply) 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 ErrIntOverflowApi
			}
			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: OnlineReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OnlineReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoomCount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RoomCount == nil {
				m.RoomCount = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowApi
					}
					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 ErrIntOverflowApi
						}
						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 ErrInvalidLengthApi
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowApi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipApi(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthApi
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RoomCount[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReceiveReq) 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 ErrIntOverflowApi
			}
			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: ReceiveReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReceiveReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType)
			}
			m.Mid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proto", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proto == nil {
				m.Proto = &push_service_broadcast_model.Proto{}
			}
			if err := m.Proto.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReceiveReply) 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 ErrIntOverflowApi
			}
			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: ReceiveReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReceiveReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proto", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proto == nil {
				m.Proto = &push_service_broadcast_model.Proto{}
			}
			if err := m.Proto.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServerListReply) 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 ErrIntOverflowApi
			}
			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: ServerListReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServerListReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TcpPort", wireType)
			}
			m.TcpPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TcpPort |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WsPort", wireType)
			}
			m.WsPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WsPort |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WssPort", wireType)
			}
			m.WssPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WssPort |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heartbeat", wireType)
			}
			m.Heartbeat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Heartbeat |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				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 ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodes = append(m.Nodes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Backoff", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Backoff == nil {
				m.Backoff = &Backoff{}
			}
			if err := m.Backoff.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeartbeatMax", wireType)
			}
			m.HeartbeatMax = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeartbeatMax |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Backoff) 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 ErrIntOverflowApi
			}
			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: Backoff: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Backoff: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxDelay", wireType)
			}
			m.MaxDelay = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxDelay |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDelay", wireType)
			}
			m.BaseDelay = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BaseDelay |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Factor", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Factor = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jitter", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Jitter = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func init() { proto.RegisterFile("app/service/main/broadcast/api/grpc/v1/api.proto", fileDescriptorApi) }

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