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

package v1

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

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type BubbleGetCurrentReq struct {
	// 用户 uid
	Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
	// 房间号
	RoomId int64 `protobuf:"varint,2,opt,name=room_id,json=roomId,proto3" json:"room_id"`
}

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

var xxx_messageInfo_BubbleGetCurrentReq proto.InternalMessageInfo

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

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

type BubbleGetCurrentResp struct {
	//
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	//
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message"`
	//
	Data *BubbleGetCurrentResp_Data `protobuf:"bytes,4,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_BubbleGetCurrentResp proto.InternalMessageInfo

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

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

func (m *BubbleGetCurrentResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *BubbleGetCurrentResp) GetData() *BubbleGetCurrentResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type BubbleGetCurrentResp_Data struct {
	// 当前气泡框ID
	Bubble int64 `protobuf:"varint,1,opt,name=bubble,proto3" json:"bubble"`
}

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

var xxx_messageInfo_BubbleGetCurrentResp_Data proto.InternalMessageInfo

func (m *BubbleGetCurrentResp_Data) GetBubble() int64 {
	if m != nil {
		return m.Bubble
	}
	return 0
}

type BubbleGetBubbleReq struct {
	// 用户 uid
	Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
	// 房间号
	RoomId int64 `protobuf:"varint,2,opt,name=room_id,json=roomId,proto3" json:"room_id"`
	// 上报上来的气泡框ID
	BubbleId int64 `protobuf:"varint,3,opt,name=bubble_id,json=bubbleId,proto3" json:"bubble_id"`
	// 上报上来的大航海信息
	GuardLevel int64 `protobuf:"varint,4,opt,name=guard_level,json=guardLevel,proto3" json:"guard_level"`
}

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

var xxx_messageInfo_BubbleGetBubbleReq proto.InternalMessageInfo

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

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

func (m *BubbleGetBubbleReq) GetBubbleId() int64 {
	if m != nil {
		return m.BubbleId
	}
	return 0
}

func (m *BubbleGetBubbleReq) GetGuardLevel() int64 {
	if m != nil {
		return m.GuardLevel
	}
	return 0
}

type BubbleGetBubbleResp struct {
	//
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	//
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message"`
	//
	Data *BubbleGetBubbleResp_Data `protobuf:"bytes,4,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_BubbleGetBubbleResp proto.InternalMessageInfo

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

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

func (m *BubbleGetBubbleResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *BubbleGetBubbleResp) GetData() *BubbleGetBubbleResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type BubbleGetBubbleResp_Data struct {
	// 当前气泡框ID
	Bubble int64 `protobuf:"varint,1,opt,name=bubble,proto3" json:"bubble"`
}

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

var xxx_messageInfo_BubbleGetBubbleResp_Data proto.InternalMessageInfo

func (m *BubbleGetBubbleResp_Data) GetBubble() int64 {
	if m != nil {
		return m.Bubble
	}
	return 0
}

type BubbleCheckAuthReq struct {
	// 用户uid
	Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
	// 房间号
	RoomId int64 `protobuf:"varint,2,opt,name=room_id,json=roomId,proto3" json:"room_id"`
	// 气泡ID
	BubbleId int64 `protobuf:"varint,3,opt,name=bubble_id,json=bubbleId,proto3" json:"bubble_id"`
}

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

var xxx_messageInfo_BubbleCheckAuthReq proto.InternalMessageInfo

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

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

func (m *BubbleCheckAuthReq) GetBubbleId() int64 {
	if m != nil {
		return m.BubbleId
	}
	return 0
}

type BubbleCheckAuthResp struct {
	//
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	//
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message"`
	//
	Data *BubbleCheckAuthResp_Data `protobuf:"bytes,4,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_BubbleCheckAuthResp proto.InternalMessageInfo

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

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

func (m *BubbleCheckAuthResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *BubbleCheckAuthResp) GetData() *BubbleCheckAuthResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type BubbleCheckAuthResp_Data struct {
	// 逻辑错误码 -1 非法 0 合法
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	// 错误原因
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message"`
}

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

var xxx_messageInfo_BubbleCheckAuthResp_Data proto.InternalMessageInfo

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

func (m *BubbleCheckAuthResp_Data) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type BubbleMultiAddReq struct {
	// 用户uid逗号拼接
	UidList string `protobuf:"bytes,1,opt,name=uid_list,json=uidList,proto3" json:"uid_list"`
	// 气泡ID
	BubbleId int64 `protobuf:"varint,2,opt,name=bubble_id,json=bubbleId,proto3" json:"bubble_id"`
	// 过期的时间戳
	ExpiredAt int64 `protobuf:"varint,3,opt,name=expired_at,json=expiredAt,proto3" json:"expired_at"`
	// 业务描述
	Desc string `protobuf:"bytes,4,opt,name=desc,proto3" json:"desc"`
	// 大区ID
	Category int64 `protobuf:"varint,5,opt,name=category,proto3" json:"category"`
	// 分区ID
	SubCategory int64 `protobuf:"varint,6,opt,name=sub_category,json=subCategory,proto3" json:"sub_category"`
	// 房间号
	RoomId int64 `protobuf:"varint,7,opt,name=room_id,json=roomId,proto3" json:"room_id"`
}

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

var xxx_messageInfo_BubbleMultiAddReq proto.InternalMessageInfo

func (m *BubbleMultiAddReq) GetUidList() string {
	if m != nil {
		return m.UidList
	}
	return ""
}

func (m *BubbleMultiAddReq) GetBubbleId() int64 {
	if m != nil {
		return m.BubbleId
	}
	return 0
}

func (m *BubbleMultiAddReq) GetExpiredAt() int64 {
	if m != nil {
		return m.ExpiredAt
	}
	return 0
}

func (m *BubbleMultiAddReq) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *BubbleMultiAddReq) GetCategory() int64 {
	if m != nil {
		return m.Category
	}
	return 0
}

func (m *BubbleMultiAddReq) GetSubCategory() int64 {
	if m != nil {
		return m.SubCategory
	}
	return 0
}

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

type BubbleMultiAddResp struct {
	//
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	//
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message"`
	//
	Data *BubbleMultiAddResp_Data `protobuf:"bytes,4,opt,name=data" json:"data"`
}

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

var xxx_messageInfo_BubbleMultiAddResp proto.InternalMessageInfo

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

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

func (m *BubbleMultiAddResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *BubbleMultiAddResp) GetData() *BubbleMultiAddResp_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type BubbleMultiAddResp_UidList struct {
	//
	Uid []int64 `protobuf:"varint,1,rep,packed,name=uid" json:"uid"`
}

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

var xxx_messageInfo_BubbleMultiAddResp_UidList proto.InternalMessageInfo

func (m *BubbleMultiAddResp_UidList) GetUid() []int64 {
	if m != nil {
		return m.Uid
	}
	return nil
}

type BubbleMultiAddResp_Data struct {
	//
	Success *BubbleMultiAddResp_UidList `protobuf:"bytes,1,opt,name=success" json:"success"`
	//
	Failed *BubbleMultiAddResp_UidList `protobuf:"bytes,2,opt,name=failed" json:"failed"`
}

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

var xxx_messageInfo_BubbleMultiAddResp_Data proto.InternalMessageInfo

func (m *BubbleMultiAddResp_Data) GetSuccess() *BubbleMultiAddResp_UidList {
	if m != nil {
		return m.Success
	}
	return nil
}

func (m *BubbleMultiAddResp_Data) GetFailed() *BubbleMultiAddResp_UidList {
	if m != nil {
		return m.Failed
	}
	return nil
}

func init() {
	proto.RegisterType((*BubbleGetCurrentReq)(nil), "userext.v1.BubbleGetCurrentReq")
	proto.RegisterType((*BubbleGetCurrentResp)(nil), "userext.v1.BubbleGetCurrentResp")
	proto.RegisterType((*BubbleGetCurrentResp_Data)(nil), "userext.v1.BubbleGetCurrentResp.Data")
	proto.RegisterType((*BubbleGetBubbleReq)(nil), "userext.v1.BubbleGetBubbleReq")
	proto.RegisterType((*BubbleGetBubbleResp)(nil), "userext.v1.BubbleGetBubbleResp")
	proto.RegisterType((*BubbleGetBubbleResp_Data)(nil), "userext.v1.BubbleGetBubbleResp.Data")
	proto.RegisterType((*BubbleCheckAuthReq)(nil), "userext.v1.BubbleCheckAuthReq")
	proto.RegisterType((*BubbleCheckAuthResp)(nil), "userext.v1.BubbleCheckAuthResp")
	proto.RegisterType((*BubbleCheckAuthResp_Data)(nil), "userext.v1.BubbleCheckAuthResp.Data")
	proto.RegisterType((*BubbleMultiAddReq)(nil), "userext.v1.BubbleMultiAddReq")
	proto.RegisterType((*BubbleMultiAddResp)(nil), "userext.v1.BubbleMultiAddResp")
	proto.RegisterType((*BubbleMultiAddResp_UidList)(nil), "userext.v1.BubbleMultiAddResp.UidList")
	proto.RegisterType((*BubbleMultiAddResp_Data)(nil), "userext.v1.BubbleMultiAddResp.Data")
}
func (m *BubbleGetCurrentReq) 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 *BubbleGetCurrentReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Uid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Uid))
	}
	if m.RoomId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.RoomId))
	}
	return i, nil
}

func (m *BubbleGetCurrentResp) 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 *BubbleGetCurrentResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if m.Data != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Data.Size()))
		n1, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

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

func (m *BubbleGetBubbleReq) 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 *BubbleGetBubbleReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Uid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Uid))
	}
	if m.RoomId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.RoomId))
	}
	if m.BubbleId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.BubbleId))
	}
	if m.GuardLevel != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.GuardLevel))
	}
	return i, nil
}

func (m *BubbleGetBubbleResp) 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 *BubbleGetBubbleResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if m.Data != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Data.Size()))
		n2, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}

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

func (m *BubbleCheckAuthReq) 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 *BubbleCheckAuthReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Uid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Uid))
	}
	if m.RoomId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.RoomId))
	}
	if m.BubbleId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.BubbleId))
	}
	return i, nil
}

func (m *BubbleCheckAuthResp) 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 *BubbleCheckAuthResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if m.Data != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Data.Size()))
		n3, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

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

func (m *BubbleMultiAddReq) 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 *BubbleMultiAddReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.UidList) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.UidList)))
		i += copy(dAtA[i:], m.UidList)
	}
	if m.BubbleId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.BubbleId))
	}
	if m.ExpiredAt != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.ExpiredAt))
	}
	if len(m.Desc) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Desc)))
		i += copy(dAtA[i:], m.Desc)
	}
	if m.Category != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Category))
	}
	if m.SubCategory != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.SubCategory))
	}
	if m.RoomId != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.RoomId))
	}
	return i, nil
}

func (m *BubbleMultiAddResp) 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 *BubbleMultiAddResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.Message) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBubble(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if m.Data != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Data.Size()))
		n4, err := m.Data.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

func (m *BubbleMultiAddResp_UidList) 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 *BubbleMultiAddResp_UidList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Uid) > 0 {
		dAtA6 := make([]byte, len(m.Uid)*10)
		var j5 int
		for _, num1 := range m.Uid {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintBubble(dAtA, i, uint64(j5))
		i += copy(dAtA[i:], dAtA6[:j5])
	}
	return i, nil
}

func (m *BubbleMultiAddResp_Data) 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 *BubbleMultiAddResp_Data) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Success != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Success.Size()))
		n7, err := m.Success.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.Failed != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBubble(dAtA, i, uint64(m.Failed.Size()))
		n8, err := m.Failed.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}

func encodeVarintBubble(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 *BubbleGetCurrentReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovBubble(uint64(m.Uid))
	}
	if m.RoomId != 0 {
		n += 1 + sovBubble(uint64(m.RoomId))
	}
	return n
}

func (m *BubbleGetCurrentResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovBubble(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovBubble(uint64(l))
	}
	return n
}

func (m *BubbleGetCurrentResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Bubble != 0 {
		n += 1 + sovBubble(uint64(m.Bubble))
	}
	return n
}

func (m *BubbleGetBubbleReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovBubble(uint64(m.Uid))
	}
	if m.RoomId != 0 {
		n += 1 + sovBubble(uint64(m.RoomId))
	}
	if m.BubbleId != 0 {
		n += 1 + sovBubble(uint64(m.BubbleId))
	}
	if m.GuardLevel != 0 {
		n += 1 + sovBubble(uint64(m.GuardLevel))
	}
	return n
}

func (m *BubbleGetBubbleResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovBubble(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovBubble(uint64(l))
	}
	return n
}

func (m *BubbleGetBubbleResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Bubble != 0 {
		n += 1 + sovBubble(uint64(m.Bubble))
	}
	return n
}

func (m *BubbleCheckAuthReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uid != 0 {
		n += 1 + sovBubble(uint64(m.Uid))
	}
	if m.RoomId != 0 {
		n += 1 + sovBubble(uint64(m.RoomId))
	}
	if m.BubbleId != 0 {
		n += 1 + sovBubble(uint64(m.BubbleId))
	}
	return n
}

func (m *BubbleCheckAuthResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovBubble(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovBubble(uint64(l))
	}
	return n
}

func (m *BubbleCheckAuthResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovBubble(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	return n
}

func (m *BubbleMultiAddReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UidList)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.BubbleId != 0 {
		n += 1 + sovBubble(uint64(m.BubbleId))
	}
	if m.ExpiredAt != 0 {
		n += 1 + sovBubble(uint64(m.ExpiredAt))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.Category != 0 {
		n += 1 + sovBubble(uint64(m.Category))
	}
	if m.SubCategory != 0 {
		n += 1 + sovBubble(uint64(m.SubCategory))
	}
	if m.RoomId != 0 {
		n += 1 + sovBubble(uint64(m.RoomId))
	}
	return n
}

func (m *BubbleMultiAddResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovBubble(uint64(m.Code))
	}
	l = len(m.Msg)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovBubble(uint64(l))
	}
	return n
}

func (m *BubbleMultiAddResp_UidList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Uid) > 0 {
		l = 0
		for _, e := range m.Uid {
			l += sovBubble(uint64(e))
		}
		n += 1 + sovBubble(uint64(l)) + l
	}
	return n
}

func (m *BubbleMultiAddResp_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Success != nil {
		l = m.Success.Size()
		n += 1 + l + sovBubble(uint64(l))
	}
	if m.Failed != nil {
		l = m.Failed.Size()
		n += 1 + l + sovBubble(uint64(l))
	}
	return n
}

func sovBubble(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozBubble(x uint64) (n int) {
	return sovBubble(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *BubbleGetCurrentReq) 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 ErrIntOverflowBubble
			}
			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: BubbleGetCurrentReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleGetCurrentReq: 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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleGetCurrentResp) 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 ErrIntOverflowBubble
			}
			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: BubbleGetCurrentResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleGetCurrentResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBubble
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &BubbleGetCurrentResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleGetBubbleReq) 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 ErrIntOverflowBubble
			}
			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: BubbleGetBubbleReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleGetBubbleReq: 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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BubbleId", wireType)
			}
			m.BubbleId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BubbleId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GuardLevel", wireType)
			}
			m.GuardLevel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GuardLevel |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleGetBubbleResp) 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 ErrIntOverflowBubble
			}
			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: BubbleGetBubbleResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleGetBubbleResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBubble
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &BubbleGetBubbleResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleCheckAuthReq) 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 ErrIntOverflowBubble
			}
			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: BubbleCheckAuthReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleCheckAuthReq: 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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BubbleId", wireType)
			}
			m.BubbleId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BubbleId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleCheckAuthResp) 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 ErrIntOverflowBubble
			}
			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: BubbleCheckAuthResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleCheckAuthResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBubble
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &BubbleCheckAuthResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleMultiAddReq) 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 ErrIntOverflowBubble
			}
			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: BubbleMultiAddReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleMultiAddReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UidList", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UidList = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BubbleId", wireType)
			}
			m.BubbleId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BubbleId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpiredAt", wireType)
			}
			m.ExpiredAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpiredAt |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
			}
			m.Category = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Category |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubCategory", wireType)
			}
			m.SubCategory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubCategory |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoomId |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleMultiAddResp) 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 ErrIntOverflowBubble
			}
			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: BubbleMultiAddResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BubbleMultiAddResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Msg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				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 ErrInvalidLengthBubble
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBubble
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBubble
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &BubbleMultiAddResp_Data{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BubbleMultiAddResp_UidList) 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 ErrIntOverflowBubble
			}
			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: UidList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UidList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBubble
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (int64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Uid = append(m.Uid, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowBubble
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthBubble
				}
				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.Uid) == 0 {
					m.Uid = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowBubble
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Uid = append(m.Uid, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBubble(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBubble
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

func init() { proto.RegisterFile("v1/Bubble.proto", fileDescriptor_Bubble_05538dd71b728df4) }

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