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

package socketapi

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/golang/protobuf/ptypes/wrappers"
import _ "spaceship/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
	// Generic not found error code
	Error_NOT_FOUND Error_Code = 8
)

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",
	8: "NOT_FOUND",
}
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,
	"NOT_FOUND":                  8,
}

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

type MatchEntry_State int32

const (
	MatchEntry_MATCH_FINDING_PLAYERS  MatchEntry_State = 0
	MatchEntry_MATCH_AWAITING_PLAYERS MatchEntry_State = 1
	MatchEntry_MATCH_JOINING_PLAYERS  MatchEntry_State = 2
	MatchEntry_GAME_CREATED           MatchEntry_State = 3
)

var MatchEntry_State_name = map[int32]string{
	0: "MATCH_FINDING_PLAYERS",
	1: "MATCH_AWAITING_PLAYERS",
	2: "MATCH_JOINING_PLAYERS",
	3: "GAME_CREATED",
}
var MatchEntry_State_value = map[string]int32{
	"MATCH_FINDING_PLAYERS":  0,
	"MATCH_AWAITING_PLAYERS": 1,
	"MATCH_JOINING_PLAYERS":  2,
	"GAME_CREATED":           3,
}

func (x MatchEntry_State) String() string {
	return proto.EnumName(MatchEntry_State_name, int32(x))
}
func (MatchEntry_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{10, 0}
}

type MatchEntry_MatchUser_State int32

const (
	MatchEntry_MatchUser_NOT_READY MatchEntry_MatchUser_State = 0
	MatchEntry_MatchUser_READY     MatchEntry_MatchUser_State = 2
)

var MatchEntry_MatchUser_State_name = map[int32]string{
	0: "NOT_READY",
	2: "READY",
}
var MatchEntry_MatchUser_State_value = map[string]int32{
	"NOT_READY": 0,
	"READY":     2,
}

func (x MatchEntry_MatchUser_State) String() string {
	return proto.EnumName(MatchEntry_MatchUser_State_name, int32(x))
}
func (MatchEntry_MatchUser_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{10, 0, 0}
}

type MatchError_Code int32

const (
	MatchError_MATCH_TIMEOUT        MatchError_Code = 0
	MatchError_MATCH_INTERNAL_ERROR MatchError_Code = 1
)

var MatchError_Code_name = map[int32]string{
	0: "MATCH_TIMEOUT",
	1: "MATCH_INTERNAL_ERROR",
}
var MatchError_Code_value = map[string]int32{
	"MATCH_TIMEOUT":        0,
	"MATCH_INTERNAL_ERROR": 1,
}

func (x MatchError_Code) String() string {
	return proto.EnumName(MatchError_Code_name, int32(x))
}
func (MatchError_Code) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{11, 0}
}

type Envelope struct {
	Cid string `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
	// Types that are valid to be assigned to Message:
	//	*Envelope_Error
	//	*Envelope_MatchError
	//	*Envelope_MatchStart
	//	*Envelope_GameUpdate
	//	*Envelope_MatchFind
	//	*Envelope_MatchJoin
	//	*Envelope_MatchLeave
	//	*Envelope_MatchEntry
	//	*Envelope_GameData
	//	*Envelope_GameUpdateResp
	Message              isEnvelope_Message `protobuf_oneof:"message"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Envelope) Reset()         { *m = Envelope{} }
func (m *Envelope) String() string { return proto.CompactTextString(m) }
func (*Envelope) ProtoMessage()    {}
func (*Envelope) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{0}
}
func (m *Envelope) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Envelope.Unmarshal(m, b)
}
func (m *Envelope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Envelope.Marshal(b, m, deterministic)
}
func (dst *Envelope) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Envelope.Merge(dst, src)
}
func (m *Envelope) XXX_Size() int {
	return xxx_messageInfo_Envelope.Size(m)
}
func (m *Envelope) XXX_DiscardUnknown() {
	xxx_messageInfo_Envelope.DiscardUnknown(m)
}

var xxx_messageInfo_Envelope proto.InternalMessageInfo

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

type isEnvelope_Message interface {
	isEnvelope_Message()
}

type Envelope_Error struct {
	Error *Error `protobuf:"bytes,2,opt,name=error,proto3,oneof"`
}

type Envelope_MatchError struct {
	MatchError *MatchError `protobuf:"bytes,3,opt,name=match_error,json=matchError,proto3,oneof"`
}

type Envelope_MatchStart struct {
	MatchStart *MatchJoinResp `protobuf:"bytes,4,opt,name=match_start,json=matchStart,proto3,oneof"`
}

type Envelope_GameUpdate struct {
	GameUpdate *GameUpdate `protobuf:"bytes,5,opt,name=game_update,json=gameUpdate,proto3,oneof"`
}

type Envelope_MatchFind struct {
	MatchFind *MatchFind `protobuf:"bytes,6,opt,name=match_find,json=matchFind,proto3,oneof"`
}

type Envelope_MatchJoin struct {
	MatchJoin *MatchJoin `protobuf:"bytes,7,opt,name=match_join,json=matchJoin,proto3,oneof"`
}

type Envelope_MatchLeave struct {
	MatchLeave *MatchLeave `protobuf:"bytes,8,opt,name=match_leave,json=matchLeave,proto3,oneof"`
}

type Envelope_MatchEntry struct {
	MatchEntry *MatchEntry `protobuf:"bytes,9,opt,name=match_entry,json=matchEntry,proto3,oneof"`
}

type Envelope_GameData struct {
	GameData *GameData `protobuf:"bytes,10,opt,name=game_data,json=gameData,proto3,oneof"`
}

type Envelope_GameUpdateResp struct {
	GameUpdateResp *GameUpdateResp `protobuf:"bytes,11,opt,name=game_update_resp,json=gameUpdateResp,proto3,oneof"`
}

func (*Envelope_Error) isEnvelope_Message() {}

func (*Envelope_MatchError) isEnvelope_Message() {}

func (*Envelope_MatchStart) isEnvelope_Message() {}

func (*Envelope_GameUpdate) isEnvelope_Message() {}

func (*Envelope_MatchFind) isEnvelope_Message() {}

func (*Envelope_MatchJoin) isEnvelope_Message() {}

func (*Envelope_MatchLeave) isEnvelope_Message() {}

func (*Envelope_MatchEntry) isEnvelope_Message() {}

func (*Envelope_GameData) isEnvelope_Message() {}

func (*Envelope_GameUpdateResp) isEnvelope_Message() {}

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

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

func (m *Envelope) GetMatchError() *MatchError {
	if x, ok := m.GetMessage().(*Envelope_MatchError); ok {
		return x.MatchError
	}
	return nil
}

func (m *Envelope) GetMatchStart() *MatchJoinResp {
	if x, ok := m.GetMessage().(*Envelope_MatchStart); ok {
		return x.MatchStart
	}
	return nil
}

func (m *Envelope) GetGameUpdate() *GameUpdate {
	if x, ok := m.GetMessage().(*Envelope_GameUpdate); ok {
		return x.GameUpdate
	}
	return nil
}

func (m *Envelope) GetMatchFind() *MatchFind {
	if x, ok := m.GetMessage().(*Envelope_MatchFind); ok {
		return x.MatchFind
	}
	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) GetMatchEntry() *MatchEntry {
	if x, ok := m.GetMessage().(*Envelope_MatchEntry); ok {
		return x.MatchEntry
	}
	return nil
}

func (m *Envelope) GetGameData() *GameData {
	if x, ok := m.GetMessage().(*Envelope_GameData); ok {
		return x.GameData
	}
	return nil
}

func (m *Envelope) GetGameUpdateResp() *GameUpdateResp {
	if x, ok := m.GetMessage().(*Envelope_GameUpdateResp); ok {
		return x.GameUpdateResp
	}
	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_MatchError)(nil),
		(*Envelope_MatchStart)(nil),
		(*Envelope_GameUpdate)(nil),
		(*Envelope_MatchFind)(nil),
		(*Envelope_MatchJoin)(nil),
		(*Envelope_MatchLeave)(nil),
		(*Envelope_MatchEntry)(nil),
		(*Envelope_GameData)(nil),
		(*Envelope_GameUpdateResp)(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_MatchError:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchError); err != nil {
			return err
		}
	case *Envelope_MatchStart:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchStart); err != nil {
			return err
		}
	case *Envelope_GameUpdate:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GameUpdate); err != nil {
			return err
		}
	case *Envelope_MatchFind:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchFind); 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_MatchEntry:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MatchEntry); err != nil {
			return err
		}
	case *Envelope_GameData:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GameData); err != nil {
			return err
		}
	case *Envelope_GameUpdateResp:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GameUpdateResp); 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_error
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchError)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchError{msg}
		return true, err
	case 4: // message.match_start
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchJoinResp)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchStart{msg}
		return true, err
	case 5: // message.game_update
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GameUpdate)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_GameUpdate{msg}
		return true, err
	case 6: // message.match_find
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchFind)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchFind{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_entry
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MatchEntry)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_MatchEntry{msg}
		return true, err
	case 10: // message.game_data
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GameData)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_GameData{msg}
		return true, err
	case 11: // message.game_update_resp
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GameUpdateResp)
		err := b.DecodeMessage(msg)
		m.Message = &Envelope_GameUpdateResp{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 += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchError:
		s := proto.Size(x.MatchError)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchStart:
		s := proto.Size(x.MatchStart)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_GameUpdate:
		s := proto.Size(x.GameUpdate)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchFind:
		s := proto.Size(x.MatchFind)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchJoin:
		s := proto.Size(x.MatchJoin)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchLeave:
		s := proto.Size(x.MatchLeave)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_MatchEntry:
		s := proto.Size(x.MatchEntry)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_GameData:
		s := proto.Size(x.GameData)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Envelope_GameUpdateResp:
		s := proto.Size(x.GameUpdateResp)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type PubSubMessage struct {
	UserIDs              []string  `protobuf:"bytes,1,rep,name=userIDs,proto3" json:"userIDs,omitempty"`
	Data                 *Envelope `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *PubSubMessage) Reset()         { *m = PubSubMessage{} }
func (m *PubSubMessage) String() string { return proto.CompactTextString(m) }
func (*PubSubMessage) ProtoMessage()    {}
func (*PubSubMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{1}
}
func (m *PubSubMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PubSubMessage.Unmarshal(m, b)
}
func (m *PubSubMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PubSubMessage.Marshal(b, m, deterministic)
}
func (dst *PubSubMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PubSubMessage.Merge(dst, src)
}
func (m *PubSubMessage) XXX_Size() int {
	return xxx_messageInfo_PubSubMessage.Size(m)
}
func (m *PubSubMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_PubSubMessage.DiscardUnknown(m)
}

var xxx_messageInfo_PubSubMessage proto.InternalMessageInfo

func (m *PubSubMessage) GetUserIDs() []string {
	if m != nil {
		return m.UserIDs
	}
	return nil
}

func (m *PubSubMessage) GetData() *Envelope {
	if m != nil {
		return m.Data
	}
	return nil
}

type GameUpdate struct {
	GameID               string   `protobuf:"bytes,1,opt,name=gameID,proto3" json:"gameID,omitempty"`
	Metadata             string   `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GameUpdate) Reset()         { *m = GameUpdate{} }
func (m *GameUpdate) String() string { return proto.CompactTextString(m) }
func (*GameUpdate) ProtoMessage()    {}
func (*GameUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{2}
}
func (m *GameUpdate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GameUpdate.Unmarshal(m, b)
}
func (m *GameUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GameUpdate.Marshal(b, m, deterministic)
}
func (dst *GameUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameUpdate.Merge(dst, src)
}
func (m *GameUpdate) XXX_Size() int {
	return xxx_messageInfo_GameUpdate.Size(m)
}
func (m *GameUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_GameUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_GameUpdate proto.InternalMessageInfo

func (m *GameUpdate) GetGameID() string {
	if m != nil {
		return m.GameID
	}
	return ""
}

func (m *GameUpdate) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

type GameUpdateQueue struct {
	GameID               string   `protobuf:"bytes,1,opt,name=gameID,proto3" json:"gameID,omitempty"`
	UserID               string   `protobuf:"bytes,2,opt,name=userID,proto3" json:"userID,omitempty"`
	Metadata             string   `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GameUpdateQueue) Reset()         { *m = GameUpdateQueue{} }
func (m *GameUpdateQueue) String() string { return proto.CompactTextString(m) }
func (*GameUpdateQueue) ProtoMessage()    {}
func (*GameUpdateQueue) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{3}
}
func (m *GameUpdateQueue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GameUpdateQueue.Unmarshal(m, b)
}
func (m *GameUpdateQueue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GameUpdateQueue.Marshal(b, m, deterministic)
}
func (dst *GameUpdateQueue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameUpdateQueue.Merge(dst, src)
}
func (m *GameUpdateQueue) XXX_Size() int {
	return xxx_messageInfo_GameUpdateQueue.Size(m)
}
func (m *GameUpdateQueue) XXX_DiscardUnknown() {
	xxx_messageInfo_GameUpdateQueue.DiscardUnknown(m)
}

var xxx_messageInfo_GameUpdateQueue proto.InternalMessageInfo

func (m *GameUpdateQueue) GetGameID() string {
	if m != nil {
		return m.GameID
	}
	return ""
}

func (m *GameUpdateQueue) GetUserID() string {
	if m != nil {
		return m.UserID
	}
	return ""
}

func (m *GameUpdateQueue) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

type GameUpdateResp struct {
	GameData             *GameData `protobuf:"bytes,1,opt,name=game_data,json=gameData,proto3" json:"game_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GameUpdateResp) Reset()         { *m = GameUpdateResp{} }
func (m *GameUpdateResp) String() string { return proto.CompactTextString(m) }
func (*GameUpdateResp) ProtoMessage()    {}
func (*GameUpdateResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{4}
}
func (m *GameUpdateResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GameUpdateResp.Unmarshal(m, b)
}
func (m *GameUpdateResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GameUpdateResp.Marshal(b, m, deterministic)
}
func (dst *GameUpdateResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameUpdateResp.Merge(dst, src)
}
func (m *GameUpdateResp) XXX_Size() int {
	return xxx_messageInfo_GameUpdateResp.Size(m)
}
func (m *GameUpdateResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GameUpdateResp.DiscardUnknown(m)
}

var xxx_messageInfo_GameUpdateResp proto.InternalMessageInfo

func (m *GameUpdateResp) GetGameData() *GameData {
	if m != nil {
		return m.GameData
	}
	return nil
}

// 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,proto3" json:"code,omitempty"`
	// A message in English to help developers debug the response.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// Additional error details which may be different for each response.
	Context              map[string]string `protobuf:"bytes,3,rep,name=context,proto3" json:"context,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Error) Reset()         { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage()    {}
func (*Error) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{5}
}
func (m *Error) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Error.Unmarshal(m, b)
}
func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Error.Marshal(b, m, deterministic)
}
func (dst *Error) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Error.Merge(dst, src)
}
func (m *Error) XXX_Size() int {
	return xxx_messageInfo_Error.Size(m)
}
func (m *Error) XXX_DiscardUnknown() {
	xxx_messageInfo_Error.DiscardUnknown(m)
}

var xxx_messageInfo_Error proto.InternalMessageInfo

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
}

type MatchJoinResp struct {
	GameData             *GameData `protobuf:"bytes,1,opt,name=game_data,json=gameData,proto3" json:"game_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *MatchJoinResp) Reset()         { *m = MatchJoinResp{} }
func (m *MatchJoinResp) String() string { return proto.CompactTextString(m) }
func (*MatchJoinResp) ProtoMessage()    {}
func (*MatchJoinResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{6}
}
func (m *MatchJoinResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchJoinResp.Unmarshal(m, b)
}
func (m *MatchJoinResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchJoinResp.Marshal(b, m, deterministic)
}
func (dst *MatchJoinResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchJoinResp.Merge(dst, src)
}
func (m *MatchJoinResp) XXX_Size() int {
	return xxx_messageInfo_MatchJoinResp.Size(m)
}
func (m *MatchJoinResp) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchJoinResp.DiscardUnknown(m)
}

var xxx_messageInfo_MatchJoinResp proto.InternalMessageInfo

func (m *MatchJoinResp) GetGameData() *GameData {
	if m != nil {
		return m.GameData
	}
	return nil
}

type MatchFind struct {
	GameName             string            `protobuf:"bytes,1,opt,name=game_name,json=gameName,proto3" json:"game_name,omitempty"`
	QueueProperties      map[string]string `protobuf:"bytes,2,rep,name=queue_properties,json=queueProperties,proto3" json:"queue_properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *MatchFind) Reset()         { *m = MatchFind{} }
func (m *MatchFind) String() string { return proto.CompactTextString(m) }
func (*MatchFind) ProtoMessage()    {}
func (*MatchFind) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{7}
}
func (m *MatchFind) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchFind.Unmarshal(m, b)
}
func (m *MatchFind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchFind.Marshal(b, m, deterministic)
}
func (dst *MatchFind) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchFind.Merge(dst, src)
}
func (m *MatchFind) XXX_Size() int {
	return xxx_messageInfo_MatchFind.Size(m)
}
func (m *MatchFind) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchFind.DiscardUnknown(m)
}

var xxx_messageInfo_MatchFind proto.InternalMessageInfo

func (m *MatchFind) GetGameName() string {
	if m != nil {
		return m.GameName
	}
	return ""
}

func (m *MatchFind) GetQueueProperties() map[string]string {
	if m != nil {
		return m.QueueProperties
	}
	return nil
}

type MatchJoin struct {
	MatchId              string   `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchJoin) Reset()         { *m = MatchJoin{} }
func (m *MatchJoin) String() string { return proto.CompactTextString(m) }
func (*MatchJoin) ProtoMessage()    {}
func (*MatchJoin) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{8}
}
func (m *MatchJoin) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchJoin.Unmarshal(m, b)
}
func (m *MatchJoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchJoin.Marshal(b, m, deterministic)
}
func (dst *MatchJoin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchJoin.Merge(dst, src)
}
func (m *MatchJoin) XXX_Size() int {
	return xxx_messageInfo_MatchJoin.Size(m)
}
func (m *MatchJoin) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchJoin.DiscardUnknown(m)
}

var xxx_messageInfo_MatchJoin proto.InternalMessageInfo

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

type MatchLeave struct {
	MatchId              string   `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchLeave) Reset()         { *m = MatchLeave{} }
func (m *MatchLeave) String() string { return proto.CompactTextString(m) }
func (*MatchLeave) ProtoMessage()    {}
func (*MatchLeave) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{9}
}
func (m *MatchLeave) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchLeave.Unmarshal(m, b)
}
func (m *MatchLeave) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchLeave.Marshal(b, m, deterministic)
}
func (dst *MatchLeave) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchLeave.Merge(dst, src)
}
func (m *MatchLeave) XXX_Size() int {
	return xxx_messageInfo_MatchLeave.Size(m)
}
func (m *MatchLeave) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchLeave.DiscardUnknown(m)
}

var xxx_messageInfo_MatchLeave proto.InternalMessageInfo

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

type MatchEntry struct {
	MatchId              string                  `protobuf:"bytes,1,opt,name=match_id,json=matchId,proto3" json:"match_id,omitempty"`
	State                int32                   `protobuf:"varint,2,opt,name=state,proto3" json:"state,omitempty"`
	MaxCount             int32                   `protobuf:"varint,3,opt,name=max_count,json=maxCount,proto3" json:"max_count,omitempty"`
	ActiveCount          int32                   `protobuf:"varint,4,opt,name=active_count,json=activeCount,proto3" json:"active_count,omitempty"`
	Game                 string                  `protobuf:"bytes,5,opt,name=game,proto3" json:"game,omitempty"`
	Users                []*MatchEntry_MatchUser `protobuf:"bytes,6,rep,name=users,proto3" json:"users,omitempty"`
	GameName             string                  `protobuf:"bytes,7,opt,name=gameName,proto3" json:"gameName,omitempty"`
	Queuekey             string                  `protobuf:"bytes,8,opt,name=queuekey,proto3" json:"queuekey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *MatchEntry) Reset()         { *m = MatchEntry{} }
func (m *MatchEntry) String() string { return proto.CompactTextString(m) }
func (*MatchEntry) ProtoMessage()    {}
func (*MatchEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{10}
}
func (m *MatchEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchEntry.Unmarshal(m, b)
}
func (m *MatchEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchEntry.Marshal(b, m, deterministic)
}
func (dst *MatchEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchEntry.Merge(dst, src)
}
func (m *MatchEntry) XXX_Size() int {
	return xxx_messageInfo_MatchEntry.Size(m)
}
func (m *MatchEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchEntry.DiscardUnknown(m)
}

var xxx_messageInfo_MatchEntry proto.InternalMessageInfo

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

func (m *MatchEntry) GetState() int32 {
	if m != nil {
		return m.State
	}
	return 0
}

func (m *MatchEntry) GetMaxCount() int32 {
	if m != nil {
		return m.MaxCount
	}
	return 0
}

func (m *MatchEntry) GetActiveCount() int32 {
	if m != nil {
		return m.ActiveCount
	}
	return 0
}

func (m *MatchEntry) GetGame() string {
	if m != nil {
		return m.Game
	}
	return ""
}

func (m *MatchEntry) GetUsers() []*MatchEntry_MatchUser {
	if m != nil {
		return m.Users
	}
	return nil
}

func (m *MatchEntry) GetGameName() string {
	if m != nil {
		return m.GameName
	}
	return ""
}

func (m *MatchEntry) GetQueuekey() string {
	if m != nil {
		return m.Queuekey
	}
	return ""
}

type MatchEntry_MatchUser struct {
	UserId               string   `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	Username             string   `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"`
	State                int32    `protobuf:"varint,3,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchEntry_MatchUser) Reset()         { *m = MatchEntry_MatchUser{} }
func (m *MatchEntry_MatchUser) String() string { return proto.CompactTextString(m) }
func (*MatchEntry_MatchUser) ProtoMessage()    {}
func (*MatchEntry_MatchUser) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{10, 0}
}
func (m *MatchEntry_MatchUser) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchEntry_MatchUser.Unmarshal(m, b)
}
func (m *MatchEntry_MatchUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchEntry_MatchUser.Marshal(b, m, deterministic)
}
func (dst *MatchEntry_MatchUser) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchEntry_MatchUser.Merge(dst, src)
}
func (m *MatchEntry_MatchUser) XXX_Size() int {
	return xxx_messageInfo_MatchEntry_MatchUser.Size(m)
}
func (m *MatchEntry_MatchUser) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchEntry_MatchUser.DiscardUnknown(m)
}

var xxx_messageInfo_MatchEntry_MatchUser proto.InternalMessageInfo

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

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

func (m *MatchEntry_MatchUser) GetState() int32 {
	if m != nil {
		return m.State
	}
	return 0
}

type MatchError struct {
	Code                 int32    `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchError) Reset()         { *m = MatchError{} }
func (m *MatchError) String() string { return proto.CompactTextString(m) }
func (*MatchError) ProtoMessage()    {}
func (*MatchError) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{11}
}
func (m *MatchError) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchError.Unmarshal(m, b)
}
func (m *MatchError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchError.Marshal(b, m, deterministic)
}
func (dst *MatchError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchError.Merge(dst, src)
}
func (m *MatchError) XXX_Size() int {
	return xxx_messageInfo_MatchError.Size(m)
}
func (m *MatchError) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchError.DiscardUnknown(m)
}

var xxx_messageInfo_MatchError proto.InternalMessageInfo

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

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

type GameData struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Metadata             string   `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	CreatedAt            int64    `protobuf:"varint,4,opt,name=createdAt,proto3" json:"createdAt,omitempty"`
	UpdatedAt            int64    `protobuf:"varint,5,opt,name=updatedAt,proto3" json:"updatedAt,omitempty"`
	GameName             string   `protobuf:"bytes,6,opt,name=gameName,proto3" json:"gameName,omitempty"`
	UserIDs              []string `protobuf:"bytes,7,rep,name=userIDs,proto3" json:"userIDs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GameData) Reset()         { *m = GameData{} }
func (m *GameData) String() string { return proto.CompactTextString(m) }
func (*GameData) ProtoMessage()    {}
func (*GameData) Descriptor() ([]byte, []int) {
	return fileDescriptor_socketapi_4aab1cc30a5fe7e8, []int{12}
}
func (m *GameData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GameData.Unmarshal(m, b)
}
func (m *GameData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GameData.Marshal(b, m, deterministic)
}
func (dst *GameData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GameData.Merge(dst, src)
}
func (m *GameData) XXX_Size() int {
	return xxx_messageInfo_GameData.Size(m)
}
func (m *GameData) XXX_DiscardUnknown() {
	xxx_messageInfo_GameData.DiscardUnknown(m)
}

var xxx_messageInfo_GameData proto.InternalMessageInfo

func (m *GameData) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *GameData) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GameData) GetMetadata() string {
	if m != nil {
		return m.Metadata
	}
	return ""
}

func (m *GameData) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *GameData) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *GameData) GetGameName() string {
	if m != nil {
		return m.GameName
	}
	return ""
}

func (m *GameData) GetUserIDs() []string {
	if m != nil {
		return m.UserIDs
	}
	return nil
}

func init() {
	proto.RegisterType((*Envelope)(nil), "spaceship.socket.Envelope")
	proto.RegisterType((*PubSubMessage)(nil), "spaceship.socket.PubSubMessage")
	proto.RegisterType((*GameUpdate)(nil), "spaceship.socket.GameUpdate")
	proto.RegisterType((*GameUpdateQueue)(nil), "spaceship.socket.GameUpdateQueue")
	proto.RegisterType((*GameUpdateResp)(nil), "spaceship.socket.GameUpdateResp")
	proto.RegisterType((*Error)(nil), "spaceship.socket.Error")
	proto.RegisterMapType((map[string]string)(nil), "spaceship.socket.Error.ContextEntry")
	proto.RegisterType((*MatchJoinResp)(nil), "spaceship.socket.MatchJoinResp")
	proto.RegisterType((*MatchFind)(nil), "spaceship.socket.MatchFind")
	proto.RegisterMapType((map[string]string)(nil), "spaceship.socket.MatchFind.QueuePropertiesEntry")
	proto.RegisterType((*MatchJoin)(nil), "spaceship.socket.MatchJoin")
	proto.RegisterType((*MatchLeave)(nil), "spaceship.socket.MatchLeave")
	proto.RegisterType((*MatchEntry)(nil), "spaceship.socket.MatchEntry")
	proto.RegisterType((*MatchEntry_MatchUser)(nil), "spaceship.socket.MatchEntry.MatchUser")
	proto.RegisterType((*MatchError)(nil), "spaceship.socket.MatchError")
	proto.RegisterType((*GameData)(nil), "spaceship.socket.GameData")
	proto.RegisterEnum("spaceship.socket.Error_Code", Error_Code_name, Error_Code_value)
	proto.RegisterEnum("spaceship.socket.MatchEntry_State", MatchEntry_State_name, MatchEntry_State_value)
	proto.RegisterEnum("spaceship.socket.MatchEntry_MatchUser_State", MatchEntry_MatchUser_State_name, MatchEntry_MatchUser_State_value)
	proto.RegisterEnum("spaceship.socket.MatchError_Code", MatchError_Code_name, MatchError_Code_value)
}

func init() {
	proto.RegisterFile("socketapi/socketapi.proto", fileDescriptor_socketapi_4aab1cc30a5fe7e8)
}

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