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

package v0

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 BroadcastSendNoticeMsgReq struct {
	// 场景常数 1: 全局 2: 一级分区 3: 二级分区 4: 房间
	SceneKey string `protobuf:"bytes,1,opt,name=scene_key,json=sceneKey,proto3" json:"scene_key"`
	// 场景值(一级分区号, 二级分区号, 房间号; 当scene_key = 1时此值被忽略)
	SceneValue string `protobuf:"bytes,2,opt,name=scene_value,json=sceneValue,proto3" json:"scene_value"`
	//
	Msg *BroadcastSendNoticeMsgReq_MSG `protobuf:"bytes,3,opt,name=msg" json:"msg"`
}

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

var xxx_messageInfo_BroadcastSendNoticeMsgReq proto.InternalMessageInfo

func (m *BroadcastSendNoticeMsgReq) GetSceneKey() string {
	if m != nil {
		return m.SceneKey
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq) GetSceneValue() string {
	if m != nil {
		return m.SceneValue
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq) GetMsg() *BroadcastSendNoticeMsgReq_MSG {
	if m != nil {
		return m.Msg
	}
	return nil
}

type BroadcastSendNoticeMsgReq_FullData struct {
	// 头图
	HeadIcon string `protobuf:"bytes,1,opt,name=head_icon,json=headIcon,proto3" json:"head_icon"`
	// 尾图
	TailIcon string `protobuf:"bytes,2,opt,name=tail_icon,json=tailIcon,proto3" json:"tail_icon"`
	// 序列帧格式头图
	HeadIconFa string `protobuf:"bytes,3,opt,name=head_icon_fa,json=headIconFa,proto3" json:"head_icon_fa"`
	// 序列帧格式尾图
	TailIconFa string `protobuf:"bytes,4,opt,name=tail_icon_fa,json=tailIconFa,proto3" json:"tail_icon_fa"`
	// 背景颜色
	Background string `protobuf:"bytes,5,opt,name=background,proto3" json:"background"`
	// 普通文字颜色
	Color string `protobuf:"bytes,6,opt,name=color,proto3" json:"color"`
	// 高亮文字颜色
	Highlight string `protobuf:"bytes,7,opt,name=highlight,proto3" json:"highlight"`
	// 持续时间
	Time int64 `protobuf:"varint,8,opt,name=time,proto3" json:"time"`
}

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

var xxx_messageInfo_BroadcastSendNoticeMsgReq_FullData proto.InternalMessageInfo

func (m *BroadcastSendNoticeMsgReq_FullData) GetHeadIcon() string {
	if m != nil {
		return m.HeadIcon
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_FullData) GetTailIcon() string {
	if m != nil {
		return m.TailIcon
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_FullData) GetHeadIconFa() string {
	if m != nil {
		return m.HeadIconFa
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_FullData) GetTailIconFa() string {
	if m != nil {
		return m.TailIconFa
	}
	return ""
}

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

func (m *BroadcastSendNoticeMsgReq_FullData) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_FullData) GetHighlight() string {
	if m != nil {
		return m.Highlight
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_FullData) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type BroadcastSendNoticeMsgReq_HalfData struct {
	// 头图
	HeadIcon string `protobuf:"bytes,1,opt,name=head_icon,json=headIcon,proto3" json:"head_icon"`
	// 尾图
	TailIcon string `protobuf:"bytes,2,opt,name=tail_icon,json=tailIcon,proto3" json:"tail_icon"`
	// 背景颜色
	Background string `protobuf:"bytes,3,opt,name=background,proto3" json:"background"`
	// 普通文字颜色
	Color string `protobuf:"bytes,4,opt,name=color,proto3" json:"color"`
	// 高亮文字颜色
	Highlight string `protobuf:"bytes,5,opt,name=highlight,proto3" json:"highlight"`
	// 持续时间
	Time int64 `protobuf:"varint,6,opt,name=time,proto3" json:"time"`
}

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

var xxx_messageInfo_BroadcastSendNoticeMsgReq_HalfData proto.InternalMessageInfo

func (m *BroadcastSendNoticeMsgReq_HalfData) GetHeadIcon() string {
	if m != nil {
		return m.HeadIcon
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_HalfData) GetTailIcon() string {
	if m != nil {
		return m.TailIcon
	}
	return ""
}

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

func (m *BroadcastSendNoticeMsgReq_HalfData) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_HalfData) GetHighlight() string {
	if m != nil {
		return m.Highlight
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_HalfData) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

type BroadcastSendNoticeMsgReq_MSG struct {
	//
	Roomid int64 `protobuf:"varint,1,opt,name=roomid,proto3" json:"roomid"`
	//
	MsgCommon string `protobuf:"bytes,2,opt,name=msg_common,json=msgCommon,proto3" json:"msg_common"`
	//
	MsgSelf string `protobuf:"bytes,3,opt,name=msg_self,json=msgSelf,proto3" json:"msg_self"`
	//
	LinkUrl string `protobuf:"bytes,4,opt,name=link_url,json=linkUrl,proto3" json:"link_url"`
	// 1-系统公告；2-小电视/摩天大楼抽奖公告； 3-总督抽奖公告；4-总督进场; 5-小电视/摩天大楼抽奖中奖公告; 6-高能公告
	MsgType int64 `protobuf:"varint,5,opt,name=msg_type,json=msgType,proto3" json:"msg_type"`
	//
	Full *BroadcastSendNoticeMsgReq_FullData `protobuf:"bytes,6,opt,name=full" json:"full"`
	//
	Half *BroadcastSendNoticeMsgReq_HalfData `protobuf:"bytes,7,opt,name=half" json:"half"`
}

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

var xxx_messageInfo_BroadcastSendNoticeMsgReq_MSG proto.InternalMessageInfo

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

func (m *BroadcastSendNoticeMsgReq_MSG) GetMsgCommon() string {
	if m != nil {
		return m.MsgCommon
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_MSG) GetMsgSelf() string {
	if m != nil {
		return m.MsgSelf
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_MSG) GetLinkUrl() string {
	if m != nil {
		return m.LinkUrl
	}
	return ""
}

func (m *BroadcastSendNoticeMsgReq_MSG) GetMsgType() int64 {
	if m != nil {
		return m.MsgType
	}
	return 0
}

func (m *BroadcastSendNoticeMsgReq_MSG) GetFull() *BroadcastSendNoticeMsgReq_FullData {
	if m != nil {
		return m.Full
	}
	return nil
}

func (m *BroadcastSendNoticeMsgReq_MSG) GetHalf() *BroadcastSendNoticeMsgReq_HalfData {
	if m != nil {
		return m.Half
	}
	return nil
}

type BroadcastSendNoticeMsgResp struct {
	//
	Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
	//
	Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
	//
	Data []int64 `protobuf:"varint,3,rep,packed,name=data" json:"data"`
}

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

var xxx_messageInfo_BroadcastSendNoticeMsgResp proto.InternalMessageInfo

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

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

func (m *BroadcastSendNoticeMsgResp) GetData() []int64 {
	if m != nil {
		return m.Data
	}
	return nil
}

func init() {
	proto.RegisterType((*BroadcastSendNoticeMsgReq)(nil), "rc.v0.BroadcastSendNoticeMsgReq")
	proto.RegisterType((*BroadcastSendNoticeMsgReq_FullData)(nil), "rc.v0.BroadcastSendNoticeMsgReq.FullData")
	proto.RegisterType((*BroadcastSendNoticeMsgReq_HalfData)(nil), "rc.v0.BroadcastSendNoticeMsgReq.HalfData")
	proto.RegisterType((*BroadcastSendNoticeMsgReq_MSG)(nil), "rc.v0.BroadcastSendNoticeMsgReq.MSG")
	proto.RegisterType((*BroadcastSendNoticeMsgResp)(nil), "rc.v0.BroadcastSendNoticeMsgResp")
}
func (m *BroadcastSendNoticeMsgReq) 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 *BroadcastSendNoticeMsgReq) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SceneKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.SceneKey)))
		i += copy(dAtA[i:], m.SceneKey)
	}
	if len(m.SceneValue) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.SceneValue)))
		i += copy(dAtA[i:], m.SceneValue)
	}
	if m.Msg != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Msg.Size()))
		n1, err := m.Msg.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

func (m *BroadcastSendNoticeMsgReq_FullData) 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 *BroadcastSendNoticeMsgReq_FullData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.HeadIcon) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.HeadIcon)))
		i += copy(dAtA[i:], m.HeadIcon)
	}
	if len(m.TailIcon) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.TailIcon)))
		i += copy(dAtA[i:], m.TailIcon)
	}
	if len(m.HeadIconFa) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.HeadIconFa)))
		i += copy(dAtA[i:], m.HeadIconFa)
	}
	if len(m.TailIconFa) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.TailIconFa)))
		i += copy(dAtA[i:], m.TailIconFa)
	}
	if len(m.Background) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Background)))
		i += copy(dAtA[i:], m.Background)
	}
	if len(m.Color) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Color)))
		i += copy(dAtA[i:], m.Color)
	}
	if len(m.Highlight) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Highlight)))
		i += copy(dAtA[i:], m.Highlight)
	}
	if m.Time != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Time))
	}
	return i, nil
}

func (m *BroadcastSendNoticeMsgReq_HalfData) 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 *BroadcastSendNoticeMsgReq_HalfData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.HeadIcon) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.HeadIcon)))
		i += copy(dAtA[i:], m.HeadIcon)
	}
	if len(m.TailIcon) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.TailIcon)))
		i += copy(dAtA[i:], m.TailIcon)
	}
	if len(m.Background) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Background)))
		i += copy(dAtA[i:], m.Background)
	}
	if len(m.Color) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Color)))
		i += copy(dAtA[i:], m.Color)
	}
	if len(m.Highlight) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Highlight)))
		i += copy(dAtA[i:], m.Highlight)
	}
	if m.Time != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Time))
	}
	return i, nil
}

func (m *BroadcastSendNoticeMsgReq_MSG) 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 *BroadcastSendNoticeMsgReq_MSG) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Roomid != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Roomid))
	}
	if len(m.MsgCommon) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.MsgCommon)))
		i += copy(dAtA[i:], m.MsgCommon)
	}
	if len(m.MsgSelf) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.MsgSelf)))
		i += copy(dAtA[i:], m.MsgSelf)
	}
	if len(m.LinkUrl) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.LinkUrl)))
		i += copy(dAtA[i:], m.LinkUrl)
	}
	if m.MsgType != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.MsgType))
	}
	if m.Full != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Full.Size()))
		n2, err := m.Full.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Half != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Half.Size()))
		n3, err := m.Half.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

func (m *BroadcastSendNoticeMsgResp) 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 *BroadcastSendNoticeMsgResp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Code != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(m.Code))
	}
	if len(m.Msg) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Msg)))
		i += copy(dAtA[i:], m.Msg)
	}
	if len(m.Data) > 0 {
		dAtA5 := make([]byte, len(m.Data)*10)
		var j4 int
		for _, num1 := range m.Data {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintBroadcast(dAtA, i, uint64(j4))
		i += copy(dAtA[i:], dAtA5[:j4])
	}
	return i, nil
}

func encodeVarintBroadcast(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 *BroadcastSendNoticeMsgReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SceneKey)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.SceneValue)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	if m.Msg != nil {
		l = m.Msg.Size()
		n += 1 + l + sovBroadcast(uint64(l))
	}
	return n
}

func (m *BroadcastSendNoticeMsgReq_FullData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.HeadIcon)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.TailIcon)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.HeadIconFa)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.TailIconFa)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.Background)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.Highlight)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovBroadcast(uint64(m.Time))
	}
	return n
}

func (m *BroadcastSendNoticeMsgReq_HalfData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.HeadIcon)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.TailIcon)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.Background)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.Highlight)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovBroadcast(uint64(m.Time))
	}
	return n
}

func (m *BroadcastSendNoticeMsgReq_MSG) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Roomid != 0 {
		n += 1 + sovBroadcast(uint64(m.Roomid))
	}
	l = len(m.MsgCommon)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.MsgSelf)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	l = len(m.LinkUrl)
	if l > 0 {
		n += 1 + l + sovBroadcast(uint64(l))
	}
	if m.MsgType != 0 {
		n += 1 + sovBroadcast(uint64(m.MsgType))
	}
	if m.Full != nil {
		l = m.Full.Size()
		n += 1 + l + sovBroadcast(uint64(l))
	}
	if m.Half != nil {
		l = m.Half.Size()
		n += 1 + l + sovBroadcast(uint64(l))
	}
	return n
}

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

func sovBroadcast(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozBroadcast(x uint64) (n int) {
	return sovBroadcast(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *BroadcastSendNoticeMsgReq) 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 ErrIntOverflowBroadcast
			}
			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: BroadcastSendNoticeMsgReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BroadcastSendNoticeMsgReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SceneKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SceneKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SceneValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SceneValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Msg == nil {
				m.Msg = &BroadcastSendNoticeMsgReq_MSG{}
			}
			if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroadcast(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroadcast
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BroadcastSendNoticeMsgReq_FullData) 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 ErrIntOverflowBroadcast
			}
			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: FullData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FullData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeadIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TailIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TailIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadIconFa", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeadIconFa = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TailIconFa", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TailIconFa = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Background", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Background = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Highlight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Highlight = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroadcast(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroadcast
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BroadcastSendNoticeMsgReq_HalfData) 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 ErrIntOverflowBroadcast
			}
			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: HalfData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HalfData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeadIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeadIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TailIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TailIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Background", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Background = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Highlight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Highlight = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBroadcast(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroadcast
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BroadcastSendNoticeMsgReq_MSG) 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 ErrIntOverflowBroadcast
			}
			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: MSG: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MSG: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Roomid", wireType)
			}
			m.Roomid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Roomid |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgCommon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MsgCommon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgSelf", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MsgSelf = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				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 ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgType", wireType)
			}
			m.MsgType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgType |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Full", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Full == nil {
				m.Full = &BroadcastSendNoticeMsgReq_FullData{}
			}
			if err := m.Full.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Half", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBroadcast
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBroadcast
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Half == nil {
				m.Half = &BroadcastSendNoticeMsgReq_HalfData{}
			}
			if err := m.Half.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBroadcast(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthBroadcast
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

func init() { proto.RegisterFile("v0/Broadcast.proto", fileDescriptor_Broadcast_32ece6a4f6b2cbe4) }

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