// Code generated by protoc-gen-go. DO NOT EDIT.
// source: rtapi/realtime.proto

/*
Package rtapi is a generated protocol buffer package.

It is generated from these files:
	rtapi/realtime.proto

It has these top-level messages:
	Envelope
	Error
	Match
	MatchCreate
	MatchData
	MatchDataSend
	MatchJoin
	MatchLeave
	MatchPresenceEvent
	Notifications
	Stream
	StreamData
	StreamPresence
	StreamPresenceEvent
*/
package rtapi

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/ptypes/wrappers"
import nakama_api "github.com/heroiclabs/nakama/api"

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

// The selection of possible error codes.
type Error_Code int32

const (
	// An unexpected result from the server.
	Error_RUNTIME_EXCEPTION Error_Code = 0
	// The server received a message which is not recognised.
	Error_UNRECOGNIZED_PAYLOAD Error_Code = 1
	// A message was expected but contains no content.
	Error_MISSING_PAYLOAD Error_Code = 2
	// Fields in the message have an invalid format.
	Error_BAD_INPUT Error_Code = 3
	// The match id was not found.
	Error_MATCH_NOT_FOUND Error_Code = 4
	// The match join was rejected.
	Error_MATCH_JOIN_REJECTED Error_Code = 5
	// The runtime function does not exist on the server.
	Error_RUNTIME_FUNCTION_NOT_FOUND Error_Code = 6
	// The runtime function executed with an error.
	Error_RUNTIME_FUNCTION_EXCEPTION Error_Code = 7
)

var Error_Code_name = map[int32]string{
	0: "RUNTIME_EXCEPTION",
	1: "UNRECOGNIZED_PAYLOAD",
	2: "MISSING_PAYLOAD",
	3: "BAD_INPUT",
	4: "MATCH_NOT_FOUND",
	5: "MATCH_JOIN_REJECTED",
	6: "RUNTIME_FUNCTION_NOT_FOUND",
	7: "RUNTIME_FUNCTION_EXCEPTION",
}
var Error_Code_value = map[string]int32{
	"RUNTIME_EXCEPTION":          0,
	"UNRECOGNIZED_PAYLOAD":       1,
	"MISSING_PAYLOAD":            2,
	"BAD_INPUT":                  3,
	"MATCH_NOT_FOUND":            4,
	"MATCH_JOIN_REJECTED":        5,
	"RUNTIME_FUNCTION_NOT_FOUND": 6,
	"RUNTIME_FUNCTION_EXCEPTION": 7,
}

func (x Error_Code) String() string {
	return proto.EnumName(Error_Code_name, int32(x))
}
func (Error_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1, 0} }

// An envelope for a realtime message.
type Envelope struct {
	Cid string `protobuf:"bytes,1,opt,name=cid" json:"cid,omitempty"`
	// Types that are valid to be assigned to Message:
	//	*Envelope_Error
	//	*Envelope_Match
	//	*Envelope_MatchCreate
	//	*Envelope_MatchData
	//	*Envelope_MatchDataSend
	//	*Envelope_MatchJoin
	//	*Envelope_MatchLeave
	//	*Envelope_MatchPresenceEvent
	//	*Envelope_Notifications
	//	*Envelope_Rpc
	//	*Envelope_StreamData
	//	*Envelope_StreamPresenceEvent
	Message isEnvelope_Message `protobuf_oneof:"message"`
}

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

type isEnvelope_Message interface {
	isEnvelope_Message()
}

type Envelope_Error struct {
	Error *Error `protobuf:"bytes,2,opt,name=error,oneof"`
}
type Envelope_Match struct {
	Match *Match `protobuf:"bytes,3,opt,name=match,oneof"`
}
type Envelope_MatchCreate struct {
	MatchCreate *MatchCreate `protobuf:"bytes,4,opt,name=match_create,json=matchCreate,oneof"`
}
type Envelope_MatchData struct {
	MatchData *MatchData `protobuf:"bytes,5,opt,name=match_data,json=matchData,oneof"`
}
type Envelope_MatchDataSend struct {
	MatchDataSend *MatchDataSend `protobuf:"bytes,6,opt,name=match_data_send,json=matchDataSend,oneof"`
}
type Envelope_MatchJoin struct {
	MatchJoin *MatchJoin `protobuf:"bytes,7,opt,name=match_join,json=matchJoin,oneof"`
}
type Envelope_MatchLeave struct {
	MatchLeave *MatchLeave `protobuf:"bytes,8,opt,name=match_leave,json=matchLeave,oneof"`
}
type Envelope_MatchPresenceEvent struct {
	MatchPresenceEvent *MatchPresenceEvent `protobuf:"bytes,9,opt,name=match_presence_event,json=matchPresenceEvent,oneof"`
}
type Envelope_Notifications struct {
	Notifications *Notifications `protobuf:"bytes,10,opt,name=notifications,oneof"`
}
type Envelope_Rpc struct {
	Rpc *nakama_api.Rpc `protobuf:"bytes,11,opt,name=rpc,oneof"`
}
type Envelope_StreamData struct {
	StreamData *StreamData `protobuf:"bytes,12,opt,name=stream_data,json=streamData,oneof"`
}
type Envelope_StreamPresenceEvent struct {
	StreamPresenceEvent *StreamPresenceEvent `protobuf:"bytes,13,opt,name=stream_presence_event,json=streamPresenceEvent,oneof"`
}

func (*Envelope_Error) isEnvelope_Message()               {}
func (*Envelope_Match) isEnvelope_Message()               {}
func (*Envelope_MatchCreate) isEnvelope_Message()         {}
func (*Envelope_MatchData) isEnvelope_Message()           {}
func (*Envelope_MatchDataSend) isEnvelope_Message()       {}
func (*Envelope_MatchJoin) isEnvelope_Message()           {}
func (*Envelope_MatchLeave) isEnvelope_Message()          {}
func (*Envelope_MatchPresenceEvent) isEnvelope_Message()  {}
func (*Envelope_Notifications) isEnvelope_Message()       {}
func (*Envelope_Rpc) isEnvelope_Message()                 {}
func (*Envelope_StreamData) isEnvelope_Message()          {}
func (*Envelope_StreamPresenceEvent) isEnvelope_Message() {}

func (m *Envelope) GetMessage() isEnvelope_Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *Envelope) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

func (m *Envelope) GetError() *Error {
	if x, ok := m.GetMessage().(*Envelope_Error); ok {
		return x.Error
	}
	return nil
}

func (m *Envelope) GetMatch() *Match {
	if x, ok := m.GetMessage().(*Envelope_Match); ok {
		return x.Match
	}
	return nil
}

func (m *Envelope) GetMatchCreate() *MatchCreate {
	if x, ok := m.GetMessage().(*Envelope_MatchCreate); ok {
		return x.MatchCreate
	}
	return nil
}

func (m *Envelope) GetMatchData() *MatchData {
	if x, ok := m.GetMessage().(*Envelope_MatchData); ok {
		return x.MatchData
	}
	return nil
}

func (m *Envelope) GetMatchDataSend() *MatchDataSend {
	if x, ok := m.GetMessage().(*Envelope_MatchDataSend); ok {
		return x.MatchDataSend
	}
	return nil
}

func (m *Envelope) GetMatchJoin() *MatchJoin {
	if x, ok := m.GetMessage().(*Envelope_MatchJoin); ok {
		return x.MatchJoin
	}
	return nil
}

func (m *Envelope) GetMatchLeave() *MatchLeave {
	if x, ok := m.GetMessage().(*Envelope_MatchLeave); ok {
		return x.MatchLeave
	}
	return nil
}

func (m *Envelope) GetMatchPresenceEvent() *MatchPresenceEvent {
	if x, ok := m.GetMessage().(*Envelope_MatchPresenceEvent); ok {
		return x.MatchPresenceEvent
	}
	return nil
}

func (m *Envelope) GetNotifications() *Notifications {
	if x, ok := m.GetMessage().(*Envelope_Notifications); ok {
		return x.Notifications
	}
	return nil
}

func (m *Envelope) GetRpc() *nakama_api.Rpc {
	if x, ok := m.GetMessage().(*Envelope_Rpc); ok {
		return x.Rpc
	}
	return nil
}

func (m *Envelope) GetStreamData() *StreamData {
	if x, ok := m.GetMessage().(*Envelope_StreamData); ok {
		return x.StreamData
	}
	return nil
}

func (m *Envelope) GetStreamPresenceEvent() *StreamPresenceEvent {
	if x, ok := m.GetMessage().(*Envelope_StreamPresenceEvent); ok {
		return x.StreamPresenceEvent
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Envelope) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Envelope_OneofMarshaler, _Envelope_OneofUnmarshaler, _Envelope_OneofSizer, []interface{}{
		(*Envelope_Error)(nil),
		(*Envelope_Match)(nil),
		(*Envelope_MatchCreate)(nil),
		(*Envelope_MatchData)(nil),
		(*Envelope_MatchDataSend)(nil),
		(*Envelope_MatchJoin)(nil),
		(*Envelope_MatchLeave)(nil),
		(*Envelope_MatchPresenceEvent)(nil),
		(*Envelope_Notifications)(nil),
		(*Envelope_Rpc)(nil),
		(*Envelope_StreamData)(nil),
		(*Envelope_StreamPresenceEvent)(nil),
	}
}

func _Envelope_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Envelope)
	// message
	switch x := m.Message.(type) {
	case *Envelope_Error:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Error); err != nil {
			return err
		}
	case *Envelope_Match:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Match); err != nil {
			return err
		}
	case *Envelope_MatchCreate:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchCreate); err != nil {
			return err
		}
	case *Envelope_MatchData:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchData); err != nil {
			return err
		}
	case *Envelope_MatchDataSend:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchDataSend); err != nil {
			return err
		}
	case *Envelope_MatchJoin:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchJoin); err != nil {
			return err
		}
	case *Envelope_MatchLeave:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchLeave); err != nil {
			return err
		}
	case *Envelope_MatchPresenceEvent:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchPresenceEvent); err != nil {
			return err
		}
	case *Envelope_Notifications:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Notifications); err != nil {
			return err
		}
	case *Envelope_Rpc:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Rpc); err != nil {
			return err
		}
	case *Envelope_StreamData:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StreamData); err != nil {
			return err
		}
	case *Envelope_StreamPresenceEvent:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StreamPresenceEvent); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Envelope.Message has unexpected type %T", x)
	}
	return nil
}

func _Envelope_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Envelope)
	switch tag {
	case 2: // message.error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Error)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Error{msg}
		return true, err
	case 3: // message.match
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Match)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Match{msg}
		return true, err
	case 4: // message.match_create
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchCreate)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchCreate{msg}
		return true, err
	case 5: // message.match_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchData)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchData{msg}
		return true, err
	case 6: // message.match_data_send
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchDataSend)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchDataSend{msg}
		return true, err
	case 7: // message.match_join
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchJoin)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchJoin{msg}
		return true, err
	case 8: // message.match_leave
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchLeave)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchLeave{msg}
		return true, err
	case 9: // message.match_presence_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchPresenceEvent)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchPresenceEvent{msg}
		return true, err
	case 10: // message.notifications
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Notifications)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Notifications{msg}
		return true, err
	case 11: // message.rpc
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(nakama_api.Rpc)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_Rpc{msg}
		return true, err
	case 12: // message.stream_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamData)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StreamData{msg}
		return true, err
	case 13: // message.stream_presence_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StreamPresenceEvent)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_StreamPresenceEvent{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Envelope_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Envelope)
	// message
	switch x := m.Message.(type) {
	case *Envelope_Error:
		s := proto.Size(x.Error)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Match:
		s := proto.Size(x.Match)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchCreate:
		s := proto.Size(x.MatchCreate)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchData:
		s := proto.Size(x.MatchData)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchDataSend:
		s := proto.Size(x.MatchDataSend)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchJoin:
		s := proto.Size(x.MatchJoin)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchLeave:
		s := proto.Size(x.MatchLeave)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchPresenceEvent:
		s := proto.Size(x.MatchPresenceEvent)
		n += proto.SizeVarint(9<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Notifications:
		s := proto.Size(x.Notifications)
		n += proto.SizeVarint(10<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_Rpc:
		s := proto.Size(x.Rpc)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StreamData:
		s := proto.Size(x.StreamData)
		n += proto.SizeVarint(12<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_StreamPresenceEvent:
		s := proto.Size(x.StreamPresenceEvent)
		n += proto.SizeVarint(13<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A logical error which may occur on the server.
type Error struct {
	// The error code which should be one of "Error.Code" enums.
	Code int32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
	// A message in English to help developers debug the response.
	Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	// Additional error details which may be different for each response.
	Context map[string]string `protobuf:"bytes,3,rep,name=context" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

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

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

func (m *Error) GetContext() map[string]string {
	if m != nil {
		return m.Context
	}
	return nil
}

// A realtime match.
type Match struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId" json:"match_id,omitempty"`
	// True if it's an server-managed authoritative match, false otherwise.
	Authoritative bool `protobuf:"varint,2,opt,name=authoritative" json:"authoritative,omitempty"`
	// Match label, if any.
	Label *google_protobuf.StringValue `protobuf:"bytes,3,opt,name=label" json:"label,omitempty"`
	// The number of users currently in the match.
	Size int32 `protobuf:"varint,4,opt,name=size" json:"size,omitempty"`
	// The users currently in the match.
	Presences []*StreamPresence `protobuf:"bytes,5,rep,name=presences" json:"presences,omitempty"`
	// A reference to the current user's presence in the match.
	Self *StreamPresence `protobuf:"bytes,6,opt,name=self" json:"self,omitempty"`
}

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

func (m *Match) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *Match) GetAuthoritative() bool {
	if m != nil {
		return m.Authoritative
	}
	return false
}

func (m *Match) GetLabel() *google_protobuf.StringValue {
	if m != nil {
		return m.Label
	}
	return nil
}

func (m *Match) GetSize() int32 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *Match) GetPresences() []*StreamPresence {
	if m != nil {
		return m.Presences
	}
	return nil
}

func (m *Match) GetSelf() *StreamPresence {
	if m != nil {
		return m.Self
	}
	return nil
}

// Create a new realtime match.
type MatchCreate struct {
}

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

// Realtime match data received from the server.
type MatchData struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId" json:"match_id,omitempty"`
	// A reference to the user presence that sent this data, if any.
	Presence *StreamPresence `protobuf:"bytes,2,opt,name=presence" json:"presence,omitempty"`
	// Op code value.
	OpCode int64 `protobuf:"varint,3,opt,name=op_code,json=opCode" json:"op_code,omitempty"`
	// Data payload, if any.
	Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *MatchData) Reset()                    { *m = MatchData{} }
func (m *MatchData) String() string            { return proto.CompactTextString(m) }
func (*MatchData) ProtoMessage()               {}
func (*MatchData) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *MatchData) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *MatchData) GetPresence() *StreamPresence {
	if m != nil {
		return m.Presence
	}
	return nil
}

func (m *MatchData) GetOpCode() int64 {
	if m != nil {
		return m.OpCode
	}
	return 0
}

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

// Send realtime match data to the server.
type MatchDataSend struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId" json:"match_id,omitempty"`
	// Op code value.
	OpCode int64 `protobuf:"varint,2,opt,name=op_code,json=opCode" json:"op_code,omitempty"`
	// Data payload, if any.
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	// List of presences in the match to deliver to, if filtering is required. Otherwise deliver to everyone in the match.
	Presences []*StreamPresence `protobuf:"bytes,4,rep,name=presences" json:"presences,omitempty"`
}

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

func (m *MatchDataSend) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *MatchDataSend) GetOpCode() int64 {
	if m != nil {
		return m.OpCode
	}
	return 0
}

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

func (m *MatchDataSend) GetPresences() []*StreamPresence {
	if m != nil {
		return m.Presences
	}
	return nil
}

// Join an existing realtime match.
type MatchJoin struct {
	// Types that are valid to be assigned to Id:
	//	*MatchJoin_MatchId
	//	*MatchJoin_Token
	Id isMatchJoin_Id `protobuf_oneof:"id"`
}

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

type isMatchJoin_Id interface {
	isMatchJoin_Id()
}

type MatchJoin_MatchId struct {
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId,oneof"`
}
type MatchJoin_Token struct {
	Token string `protobuf:"bytes,2,opt,name=token,oneof"`
}

func (*MatchJoin_MatchId) isMatchJoin_Id() {}
func (*MatchJoin_Token) isMatchJoin_Id()   {}

func (m *MatchJoin) GetId() isMatchJoin_Id {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *MatchJoin) GetMatchId() string {
	if x, ok := m.GetId().(*MatchJoin_MatchId); ok {
		return x.MatchId
	}
	return ""
}

func (m *MatchJoin) GetToken() string {
	if x, ok := m.GetId().(*MatchJoin_Token); ok {
		return x.Token
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*MatchJoin) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _MatchJoin_OneofMarshaler, _MatchJoin_OneofUnmarshaler, _MatchJoin_OneofSizer, []interface{}{
		(*MatchJoin_MatchId)(nil),
		(*MatchJoin_Token)(nil),
	}
}

func _MatchJoin_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*MatchJoin)
	// id
	switch x := m.Id.(type) {
	case *MatchJoin_MatchId:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.MatchId)
	case *MatchJoin_Token:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Token)
	case nil:
	default:
		return fmt.Errorf("MatchJoin.Id has unexpected type %T", x)
	}
	return nil
}

func _MatchJoin_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*MatchJoin)
	switch tag {
	case 1: // id.match_id
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Id = &MatchJoin_MatchId{x}
		return true, err
	case 2: // id.token
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Id = &MatchJoin_Token{x}
		return true, err
	default:
		return false, nil
	}
}

func _MatchJoin_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*MatchJoin)
	// id
	switch x := m.Id.(type) {
	case *MatchJoin_MatchId:
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.MatchId)))
		n += len(x.MatchId)
	case *MatchJoin_Token:
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Token)))
		n += len(x.Token)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Leave a realtime match.
type MatchLeave struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId" json:"match_id,omitempty"`
}

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

func (m *MatchLeave) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

// A set of joins and leaves on a particular realtime match.
type MatchPresenceEvent struct {
	// The match unique ID.
	MatchId string `protobuf:"bytes,1,opt,name=match_id,json=matchId" json:"match_id,omitempty"`
	// User presences that have just joined the match.
	Joins []*StreamPresence `protobuf:"bytes,2,rep,name=joins" json:"joins,omitempty"`
	// User presences that have just left the match.
	Leaves []*StreamPresence `protobuf:"bytes,3,rep,name=leaves" json:"leaves,omitempty"`
}

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

func (m *MatchPresenceEvent) GetMatchId() string {
	if m != nil {
		return m.MatchId
	}
	return ""
}

func (m *MatchPresenceEvent) GetJoins() []*StreamPresence {
	if m != nil {
		return m.Joins
	}
	return nil
}

func (m *MatchPresenceEvent) GetLeaves() []*StreamPresence {
	if m != nil {
		return m.Leaves
	}
	return nil
}

// A collection of zero or more notifications.
type Notifications struct {
	// Collection of notifications.
	Notifications []*nakama_api.Notification `protobuf:"bytes,1,rep,name=notifications" json:"notifications,omitempty"`
}

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

func (m *Notifications) GetNotifications() []*nakama_api.Notification {
	if m != nil {
		return m.Notifications
	}
	return nil
}

// Represents identifying information for a stream.
type Stream struct {
	// Mode identifies the type of stream.
	Mode int32 `protobuf:"varint,1,opt,name=mode" json:"mode,omitempty"`
	// Subject is the primary identifier, if any.
	Subject string `protobuf:"bytes,2,opt,name=subject" json:"subject,omitempty"`
	// Descriptor is a secondary identifier, if any.
	Descriptor_ string `protobuf:"bytes,3,opt,name=descriptor" json:"descriptor,omitempty"`
	// The label is an arbitrary identifying string, if the stream has one.
	Label string `protobuf:"bytes,4,opt,name=label" json:"label,omitempty"`
}

func (m *Stream) Reset()                    { *m = Stream{} }
func (m *Stream) String() string            { return proto.CompactTextString(m) }
func (*Stream) ProtoMessage()               {}
func (*Stream) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }

func (m *Stream) GetMode() int32 {
	if m != nil {
		return m.Mode
	}
	return 0
}

func (m *Stream) GetSubject() string {
	if m != nil {
		return m.Subject
	}
	return ""
}

func (m *Stream) GetDescriptor_() string {
	if m != nil {
		return m.Descriptor_
	}
	return ""
}

func (m *Stream) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

// A data message delivered over a stream.
type StreamData struct {
	// The stream this data message relates to.
	Stream *Stream `protobuf:"bytes,1,opt,name=stream" json:"stream,omitempty"`
	// The sender, if any.
	Sender *StreamPresence `protobuf:"bytes,2,opt,name=sender" json:"sender,omitempty"`
	// Arbitrary contents of the data message.
	Data string `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"`
}

func (m *StreamData) Reset()                    { *m = StreamData{} }
func (m *StreamData) String() string            { return proto.CompactTextString(m) }
func (*StreamData) ProtoMessage()               {}
func (*StreamData) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }

func (m *StreamData) GetStream() *Stream {
	if m != nil {
		return m.Stream
	}
	return nil
}

func (m *StreamData) GetSender() *StreamPresence {
	if m != nil {
		return m.Sender
	}
	return nil
}

func (m *StreamData) GetData() string {
	if m != nil {
		return m.Data
	}
	return ""
}

// A user session associated to a stream, usually through a list operation or a join/leave event.
type StreamPresence struct {
	// The user this presence belongs to.
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId" json:"user_id,omitempty"`
	// A unique session ID identifying the particular connection, because the user may have many.
	SessionId string `protobuf:"bytes,2,opt,name=session_id,json=sessionId" json:"session_id,omitempty"`
	// The username for display purposes.
	Username string `protobuf:"bytes,3,opt,name=username" json:"username,omitempty"`
	// Whether this presence generates persistent data/messages, if applicable for the stream type.
	Persistence bool `protobuf:"varint,4,opt,name=persistence" json:"persistence,omitempty"`
	// A user-set status message for this stream, if applicable.
	Status string `protobuf:"bytes,5,opt,name=status" json:"status,omitempty"`
}

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

func (m *StreamPresence) GetUserId() string {
	if m != nil {
		return m.UserId
	}
	return ""
}

func (m *StreamPresence) GetSessionId() string {
	if m != nil {
		return m.SessionId
	}
	return ""
}

func (m *StreamPresence) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *StreamPresence) GetPersistence() bool {
	if m != nil {
		return m.Persistence
	}
	return false
}

func (m *StreamPresence) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

// A set of joins and leaves on a particular stream.
type StreamPresenceEvent struct {
	// The stream this event relates to.
	Stream *Stream `protobuf:"bytes,1,opt,name=stream" json:"stream,omitempty"`
	// Presences joining the stream as part of this event, if any.
	Joins []*StreamPresence `protobuf:"bytes,2,rep,name=joins" json:"joins,omitempty"`
	// Presences leaving the stream as part of this event, if any.
	Leaves []*StreamPresence `protobuf:"bytes,3,rep,name=leaves" json:"leaves,omitempty"`
}

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

func (m *StreamPresenceEvent) GetStream() *Stream {
	if m != nil {
		return m.Stream
	}
	return nil
}

func (m *StreamPresenceEvent) GetJoins() []*StreamPresence {
	if m != nil {
		return m.Joins
	}
	return nil
}

func (m *StreamPresenceEvent) GetLeaves() []*StreamPresence {
	if m != nil {
		return m.Leaves
	}
	return nil
}

func init() {
	proto.RegisterType((*Envelope)(nil), "nakama.realtime.Envelope")
	proto.RegisterType((*Error)(nil), "nakama.realtime.Error")
	proto.RegisterType((*Match)(nil), "nakama.realtime.Match")
	proto.RegisterType((*MatchCreate)(nil), "nakama.realtime.MatchCreate")
	proto.RegisterType((*MatchData)(nil), "nakama.realtime.MatchData")
	proto.RegisterType((*MatchDataSend)(nil), "nakama.realtime.MatchDataSend")
	proto.RegisterType((*MatchJoin)(nil), "nakama.realtime.MatchJoin")
	proto.RegisterType((*MatchLeave)(nil), "nakama.realtime.MatchLeave")
	proto.RegisterType((*MatchPresenceEvent)(nil), "nakama.realtime.MatchPresenceEvent")
	proto.RegisterType((*Notifications)(nil), "nakama.realtime.Notifications")
	proto.RegisterType((*Stream)(nil), "nakama.realtime.Stream")
	proto.RegisterType((*StreamData)(nil), "nakama.realtime.StreamData")
	proto.RegisterType((*StreamPresence)(nil), "nakama.realtime.StreamPresence")
	proto.RegisterType((*StreamPresenceEvent)(nil), "nakama.realtime.StreamPresenceEvent")
	proto.RegisterEnum("nakama.realtime.Error_Code", Error_Code_name, Error_Code_value)
}

func init() { proto.RegisterFile("rtapi/realtime.proto", fileDescriptor0) }

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